home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 98 / Skunkware 98.iso / src / interp / perl-5.003.tar.gz / perl-5.003.tar / perl-5.003 / lib / ExtUtils / MM_VMS.pm < prev    next >
Text File  |  1996-06-24  |  68KB  |  2,255 lines
  1. #   MM_VMS.pm
  2. #   MakeMaker default methods for VMS
  3. #   This package is inserted into @ISA of MakeMaker's MM before the
  4. #   built-in ExtUtils::MM_Unix methods if MakeMaker.pm is run under VMS.
  5. #
  6. #   Author:  Charles Bailey  bailey@genetics.upenn.edu
  7.  
  8. package ExtUtils::MM_VMS;
  9. $ExtUtils::MM_VMS::Revision=$ExtUtils::MM_VMS::Revision = '5.35 (23-Jun-1996)';
  10. unshift @MM::ISA, 'ExtUtils::MM_VMS';
  11.  
  12. use Config;
  13. require Exporter;
  14. use VMS::Filespec;
  15. use File::Basename;
  16.  
  17. Exporter::import('ExtUtils::MakeMaker', '$Verbose', '&neatvalue');
  18.  
  19. =head1 NAME
  20.  
  21. ExtUtils::MM_VMS - methods to override UN*X behaviour in ExtUtils::MakeMaker
  22.  
  23. =head1 SYNOPSIS
  24.  
  25.  use ExtUtils::MM_VMS; # Done internally by ExtUtils::MakeMaker if needed
  26.  
  27. =head1 DESCRIPTION
  28.  
  29. See ExtUtils::MM_Unix for a documentation of the methods provided
  30. there. This package overrides the implementation of these methods, not
  31. the semantics.
  32.  
  33. =head2 Methods always loaded
  34.  
  35. =item eliminate_macros
  36.  
  37. Expands MM[KS]/Make macros in a text string, using the contents of
  38. identically named elements of C<%$self>, and returns the result
  39. as a file specification in Unix syntax.
  40.  
  41. =cut
  42.  
  43. sub eliminate_macros {
  44.     my($self,$path) = @_;
  45.     unless ($path) {
  46.     print "eliminate_macros('') = ||\n" if $Verbose >= 3;
  47.     return '';
  48.     }
  49.     my($npath) = unixify($path);
  50.     my($head,$macro,$tail);
  51.  
  52.     # perform m##g in scalar context so it acts as an iterator
  53.     while ($npath =~ m#(.*?)\$\((\S+?)\)(.*)#g) { 
  54.         if ($self->{$2}) {
  55.             ($head,$macro,$tail) = ($1,$2,$3);
  56.             ($macro = unixify($self->{$macro})) =~ s#/$##;
  57.             $npath = "$head$macro$tail";
  58.         }
  59.     }
  60.     print "eliminate_macros($path) = |$npath|\n" if $Verbose >= 3;
  61.     $npath;
  62. }
  63.  
  64. =item fixpath
  65.  
  66. Catchall routine to clean up problem MM[SK]/Make macros.  Expands macros
  67. in any directory specification, in order to avoid juxtaposing two
  68. VMS-syntax directories when MM[SK] is run.  Also expands expressions which
  69. are all macro, so that we can tell how long the expansion is, and avoid
  70. overrunning DCL's command buffer when MM[KS] is running.
  71.  
  72. If optional second argument has a TRUE value, then the return string is
  73. a VMS-syntax directory specification, otherwise it is a VMS-syntax file
  74. specification.
  75.  
  76. =cut
  77.  
  78. sub fixpath {
  79.     my($self,$path,$force_path) = @_;
  80.     unless ($path) {
  81.     print "eliminate_macros('') = ||\n" if $Verbose >= 3;
  82.     return '';
  83.     }
  84.     my($fixedpath,$prefix,$name);
  85.  
  86.     if ($path =~ m#^\$\(.+\)$# || $path =~ m#[/:>\]]#) { 
  87.         if ($force_path or $path =~ /(?:DIR\)|\])$/) {
  88.             $fixedpath = vmspath($self->eliminate_macros($path));
  89.         }
  90.         else {
  91.             $fixedpath = vmsify($self->eliminate_macros($path));
  92.         }
  93.     }
  94.     elsif ((($prefix,$name) = ($path =~ m#^\$\(([^\)]+)\)(.+)#)) && $self->{$prefix}) {
  95.         my($vmspre) = vmspath($self->{$prefix}) || ''; # is it a dir or just a name?
  96.         $fixedpath = ($vmspre ? $vmspre : $self->{$prefix}) . $name;
  97.         $fixedpath = vmspath($fixedpath) if $force_path;
  98.     }
  99.     else {
  100.         $fixedpath = $path;
  101.         $fixedpath = vmspath($fixedpath) if $force_path;
  102.     }
  103.     # Convert names without directory or type to paths
  104.     if (!$force_path and $fixedpath !~ /[:>(.\]]/) { $fixedpath = vmspath($fixedpath); }
  105.     print "fixpath($path) = |$fixedpath|\n" if $Verbose >= 3;
  106.     $fixedpath;
  107. }
  108.  
  109. =item catdir
  110.  
  111. Concatenates a list of file specifications, and returns the result as a
  112. VMS-syntax directory specification.
  113.  
  114. =cut
  115.  
  116. sub catdir {
  117.     my($self,@dirs) = @_;
  118.     my($dir) = pop @dirs;
  119.     @dirs = grep($_,@dirs);
  120.     my($rslt);
  121.     if (@dirs) {
  122.       my($path) = (@dirs == 1 ? $dirs[0] : $self->catdir(@dirs));
  123.       my($spath,$sdir) = ($path,$dir);
  124.       $spath =~ s/.dir$//; $sdir =~ s/.dir$//; 
  125.       $sdir = $self->eliminate_macros($sdir) unless $sdir =~ /^[\w\-]+$/;
  126.       $rslt = vmspath($self->eliminate_macros($spath)."/$sdir");
  127.     }
  128.     else { $rslt = vmspath($dir); }
  129.     print "catdir(",join(',',@_[1..$#_]),") = |$rslt|\n" if $Verbose >= 3;
  130.     $rslt;
  131. }
  132.  
  133. =item catfile
  134.  
  135. Concatenates a list of file specifications, and returns the result as a
  136. VMS-syntax directory specification.
  137.  
  138. =cut
  139.  
  140. sub catfile {
  141.     my($self,@files) = @_;
  142.     my($file) = pop @files;
  143.     @files = grep($_,@files);
  144.     my($rslt);
  145.     if (@files) {
  146.       my($path) = (@files == 1 ? $files[0] : $self->catdir(@files));
  147.       my($spath) = $path;
  148.       $spath =~ s/.dir$//;
  149.       if ( $spath =~ /^[^\)\]\/:>]+\)$/ && basename($file) eq $file) { $rslt = "$spath$file"; }
  150.       else {
  151.           $rslt = $self->eliminate_macros($spath);
  152.           $rslt = vmsify($rslt.($rslt ? '/' : '').unixify($file));
  153.       }
  154.     }
  155.     else { $rslt = vmsify($file); }
  156.     print "catfile(",join(',',@_[1..$#_]),") = |$rslt|\n" if $Verbose >= 3;
  157.     $rslt;
  158. }
  159.  
  160. =item curdir (override)
  161.  
  162. Returns a string representing of the current directory.
  163.  
  164. =cut
  165.  
  166. sub curdir {
  167.     return '[]';
  168. }
  169.  
  170. =item rootdir (override)
  171.  
  172. Returns a string representing of the root directory.
  173.  
  174. =cut
  175.  
  176. sub rootdir {
  177.     return '';
  178. }
  179.  
  180. =item updir (override)
  181.  
  182. Returns a string representing of the parent directory.
  183.  
  184. =cut
  185.  
  186. sub updir {
  187.     return '[-]';
  188. }
  189.  
  190. package ExtUtils::MM_VMS;
  191.  
  192. sub ExtUtils::MM_VMS::guess_name;
  193. sub ExtUtils::MM_VMS::find_perl;
  194. sub ExtUtils::MM_VMS::path;
  195. sub ExtUtils::MM_VMS::maybe_command;
  196. sub ExtUtils::MM_VMS::maybe_command_in_dirs;
  197. sub ExtUtils::MM_VMS::perl_script;
  198. sub ExtUtils::MM_VMS::file_name_is_absolute;
  199. sub ExtUtils::MM_VMS::replace_manpage_separator;
  200. sub ExtUtils::MM_VMS::init_others;
  201. sub ExtUtils::MM_VMS::constants;
  202. sub ExtUtils::MM_VMS::const_loadlibs;
  203. sub ExtUtils::MM_VMS::cflags;
  204. sub ExtUtils::MM_VMS::const_cccmd;
  205. sub ExtUtils::MM_VMS::pm_to_blib;
  206. sub ExtUtils::MM_VMS::tool_autosplit;
  207. sub ExtUtils::MM_VMS::tool_xsubpp;
  208. sub ExtUtils::MM_VMS::xsubpp_version;
  209. sub ExtUtils::MM_VMS::tools_other;
  210. sub ExtUtils::MM_VMS::dist;
  211. sub ExtUtils::MM_VMS::c_o;
  212. sub ExtUtils::MM_VMS::xs_c;
  213. sub ExtUtils::MM_VMS::xs_o;
  214. sub ExtUtils::MM_VMS::top_targets;
  215. sub ExtUtils::MM_VMS::dlsyms;
  216. sub ExtUtils::MM_VMS::dynamic_lib;
  217. sub ExtUtils::MM_VMS::dynamic_bs;
  218. sub ExtUtils::MM_VMS::static_lib;
  219. sub ExtUtils::MM_VMS::manifypods;
  220. sub ExtUtils::MM_VMS::processPL;
  221. sub ExtUtils::MM_VMS::installbin;
  222. sub ExtUtils::MM_VMS::subdir_x;
  223. sub ExtUtils::MM_VMS::clean;
  224. sub ExtUtils::MM_VMS::realclean;
  225. sub ExtUtils::MM_VMS::dist_basics;
  226. sub ExtUtils::MM_VMS::dist_core;
  227. sub ExtUtils::MM_VMS::dist_dir;
  228. sub ExtUtils::MM_VMS::dist_test;
  229. sub ExtUtils::MM_VMS::install;
  230. sub ExtUtils::MM_VMS::perldepend;
  231. sub ExtUtils::MM_VMS::makefile;
  232. sub ExtUtils::MM_VMS::test;
  233. sub ExtUtils::MM_VMS::test_via_harness;
  234. sub ExtUtils::MM_VMS::test_via_script;
  235. sub ExtUtils::MM_VMS::makeaperl;
  236. sub ExtUtils::MM_VMS::ext;
  237. sub ExtUtils::MM_VMS::nicetext;
  238.  
  239. #use SelfLoader;
  240. sub AUTOLOAD {
  241.     my $code;
  242.     if (defined fileno(DATA)) {
  243.     my $fh = select DATA;
  244.     my $o = $/;            # For future reads from the file.
  245.     $/ = "\n__END__\n";
  246.     $code = <DATA>;
  247.     $/ = $o;
  248.     select $fh;
  249.     close DATA;
  250.     eval $code;
  251.     if ($@) {
  252.         $@ =~ s/ at .*\n//;
  253.         Carp::croak $@;
  254.     }
  255.     } else {
  256.     warn "AUTOLOAD called unexpectedly for $AUTOLOAD"; 
  257.     }
  258.     defined(&$AUTOLOAD) or die "Myloader inconsistency error";
  259.     goto &$AUTOLOAD;
  260. }
  261.  
  262. 1;
  263.  
  264. #__DATA__
  265.  
  266. =head2 SelfLoaded methods
  267.  
  268. Those methods which override default MM_Unix methods are marked
  269. "(override)", while methods unique to MM_VMS are marked "(specific)".
  270. For overridden methods, documentation is limited to an explanation
  271. of why this method overrides the MM_Unix method; see the ExtUtils::MM_Unix
  272. documentation for more details.
  273.  
  274. =item guess_name (override)
  275.  
  276. Try to determine name of extension being built.  We begin with the name
  277. of the current directory.  Since VMS filenames are case-insensitive,
  278. however, we look for a F<.pm> file whose name matches that of the current
  279. directory (presumably the 'main' F<.pm> file for this extension), and try
  280. to find a C<package> statement from which to obtain the Mixed::Case
  281. package name.
  282.  
  283. =cut
  284.  
  285. sub guess_name {
  286.     my($self) = @_;
  287.     my($defname,$defpm);
  288.     local *PM;
  289.  
  290.     $defname = basename(fileify($ENV{'DEFAULT'}));
  291.     $defname =~ s![\d\-_]*\.dir.*$!!;  # Clip off .dir;1 suffix, and package version
  292.     $defpm = $defname;
  293.     if (open(PM,"${defpm}.pm")){
  294.         while (<PM>) {
  295.             if (/^\s*package\s+([^;]+)/i) {
  296.                 $defname = $1;
  297.                 last;
  298.             }
  299.         }
  300.         print STDOUT "Warning (non-fatal): Couldn't find package name in ${defpm}.pm;\n\t",
  301.                      "defaulting package name to $defname\n"
  302.             if eof(PM);
  303.         close PM;
  304.     }
  305.     else {
  306.         print STDOUT "Warning (non-fatal): Couldn't find ${defpm}.pm;\n\t",
  307.                      "defaulting package name to $defname\n";
  308.     }
  309.     $defname =~ s#[\d.\-_]+$##;
  310.     $defname;
  311. }
  312.  
  313. =item find_perl (override)
  314.  
  315. Use VMS file specification syntax and CLI commands to find and
  316. invoke Perl images.
  317.  
  318. =cut
  319.  
  320. sub find_perl{
  321.     my($self, $ver, $names, $dirs, $trace) = @_;
  322.     my($name,$dir,$vmsfile,@sdirs,@snames,@cand);
  323.     # Check in relative directories first, so we pick up the current
  324.     # version of Perl if we're running MakeMaker as part of the main build.
  325.     @sdirs = sort { my($absb) = file_name_is_absolute($a);
  326.                     my($absb) = file_name_is_absolute($b);
  327.                     if ($absa && $absb) { return $a cmp $b }
  328.                     else { return $absa ? 1 : ($absb ? -1 : ($a cmp $b)); }
  329.                   } @$dirs;
  330.     # Check miniperl before perl, and check names likely to contain
  331.     # version numbers before "generic" names, so we pick up an
  332.     # executable that's less likely to be from an old installation.
  333.     @snames = sort { my($ba) = $a =~ m!([^:>\]/]+)$!;  # basename
  334.                      my($bb) = $b =~ m!([^:>\]/]+)$!;
  335.                      substr($ba,0,1) cmp substr($bb,0,1)
  336.                      or -1*(length($ba) <=> length($bb)) } @$names;
  337.     if ($trace){
  338.     print "Looking for perl $ver by these names:\n";
  339.     print "\t@snames,\n";
  340.     print "in these dirs:\n";
  341.     print "\t@sdirs\n";
  342.     }
  343.     foreach $dir (@sdirs){
  344.     next unless defined $dir; # $self->{PERL_SRC} may be undefined
  345.     foreach $name (@snames){
  346.         if ($name !~ m![/:>\]]!) { push(@cand,$self->catfile($dir,$name)); }
  347.         else                     { push(@cand,$self->fixpath($name));      }
  348.     }
  349.     }
  350.     foreach $name (@cand) {
  351.     print "Checking $name\n" if ($trace >= 2);
  352.     next unless $vmsfile = $self->maybe_command($name);
  353.     $vmsfile =~ s/;[\d\-]*$//;  # Clip off version number; we can use a newer version as well
  354.     print "Executing $vmsfile\n" if ($trace >= 2);
  355.     if (`MCR $vmsfile -e "require $ver; print ""VER_OK\n"""` =~ /VER_OK/) {
  356.         print "Using PERL=MCR $vmsfile\n" if $trace;
  357.         return "MCR $vmsfile"
  358.     }
  359.     }
  360.     print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n";
  361.     0; # false and not empty
  362. }
  363.  
  364. =item path (override)
  365.  
  366. Translate logical name DCL$PATH as a searchlist, rather than trying
  367. to C<split> string value of C<$ENV{'PATH'}>.
  368.  
  369. =cut
  370.  
  371. sub path {
  372.     my(@dirs,$dir,$i);
  373.     while ($dir = $ENV{'DCL$PATH;' . $i++}) { push(@dirs,$dir); }
  374.     @dirs;
  375. }
  376.  
  377. =item maybe_command (override)
  378.  
  379. Follows VMS naming conventions for executable files.
  380. If the name passed in doesn't exactly match an executable file,
  381. appends F<.Exe> to check for executable image, and F<.Com> to check
  382. for DCL procedure.  If this fails, checks F<Sys$Share:> for an
  383. executable file having the name specified.  Finally, appends F<.Exe>
  384. and checks again.
  385.  
  386. =cut
  387.  
  388. sub maybe_command {
  389.     my($self,$file) = @_;
  390.     return $file if -x $file && ! -d _;
  391.     return "$file.exe" if -x "$file.exe";
  392.     return "$file.com" if -x "$file.com";
  393.     if ($file !~ m![/:>\]]!) {
  394.     my($shrfile) = 'Sys$Share:' . $file;
  395.     return $file if -x $shrfile && ! -d _;
  396.     return "$file.exe" if -x "$shrfile.exe";
  397.     }
  398.     return 0;
  399. }
  400.  
  401. =item maybe_command_in_dirs (override)
  402.  
  403. Uses DCL argument quoting on test command line.
  404.  
  405. =cut
  406.  
  407. sub maybe_command_in_dirs {    # $ver is optional argument if looking for perl
  408.     my($self, $names, $dirs, $trace, $ver) = @_;
  409.     my($name, $dir);
  410.     foreach $dir (@$dirs){
  411.     next unless defined $dir; # $self->{PERL_SRC} may be undefined
  412.     foreach $name (@$names){
  413.         my($abs,$tryabs);
  414.         if ($self->file_name_is_absolute($name)) {
  415.         $abs = $name;
  416.         } else {
  417.         $abs = $self->catfile($dir, $name);
  418.         }
  419.         print "Checking $abs for $name\n" if ($trace >= 2);
  420.         next unless $tryabs = $self->maybe_command($abs);
  421.         print "Substituting $tryabs instead of $abs\n" 
  422.         if ($trace >= 2 and $tryabs ne $abs);
  423.         $abs = $tryabs;
  424.         if (defined $ver) {
  425.         print "Executing $abs\n" if ($trace >= 2);
  426.         if (`$abs -e 'require $ver; print "VER_OK\n" ' 2>&1` =~ /VER_OK/) {
  427.             print "Using PERL=$abs\n" if $trace;
  428.             return $abs;
  429.         }
  430.         } else { # Do not look for perl
  431.         return $abs;
  432.         }
  433.     }
  434.     }
  435. }
  436.  
  437. =item perl_script (override)
  438.  
  439. If name passed in doesn't specify a readable file, appends F<.pl> and
  440. tries again, since it's customary to have file types on all files
  441. under VMS.
  442.  
  443. =cut
  444.  
  445. sub perl_script {
  446.     my($self,$file) = @_;
  447.     return $file if -r $file && ! -d _;
  448.     return "$file.pl" if -r "$file.pl" && ! -d _;
  449.     return '';
  450. }
  451.  
  452. =item file_name_is_absolute (override)
  453.  
  454. Checks for VMS directory spec as well as Unix separators.
  455.  
  456. =cut
  457.  
  458. sub file_name_is_absolute {
  459.     my($self,$file);
  460.     $file =~ m!^/! or $file =~ m![:<\[][^.\-]!;
  461. }
  462.  
  463. =item replace_manpage_separator
  464.  
  465. Use as separator a character which is legal in a VMS-syntax file name.
  466.  
  467. =cut
  468.  
  469. sub replace_manpage_separator {
  470.     my($self,$man) = @_;
  471.     $man = unixify($man);
  472.     $man =~ s#/+#__#g;
  473.     $man;
  474. }
  475.  
  476. =item init_others (override)
  477.  
  478. Provide VMS-specific forms of various utility commands, then hand
  479. off to the default MM_Unix method.
  480.  
  481. =cut
  482.  
  483. sub init_others {
  484.     my($self) = @_;
  485.  
  486.     $self->{NOOP} = "\t@ Continue";
  487.     $self->{FIRST_MAKEFILE} ||= 'Descrip.MMS';
  488.     $self->{MAKE_APERL_FILE} ||= 'Makeaperl.MMS';
  489.     $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE};
  490.     $self->{NOECHO} ||= '@ ';
  491.     $self->{RM_F} = '$(PERL) -e "foreach (@ARGV) { 1 while ( -d $_ ? rmdir $_ : unlink $_)}"';
  492.     $self->{RM_RF} = '$(PERL) "-I$(PERL_LIB)" -e "use File::Path; @dirs = map(VMS::Filespec::unixify($_),@ARGV); rmtree(\@dirs,0,0)"';
  493.     $self->{TOUCH} = '$(PERL) -e "$t=time; foreach (@ARGV) { -e $_ ? utime($t,$t,@ARGV) : (open(F,qq(>$_)),close F)}"';
  494.     $self->{CHMOD} = '$(PERL) -e "chmod @ARGV"';  # expect Unix syntax from MakeMaker
  495.     $self->{CP} = 'Copy/NoConfirm';
  496.     $self->{MV} = 'Rename/NoConfirm';
  497.     $self->{UMASK_NULL} = "\t!";  
  498.     &ExtUtils::MM_Unix::init_others;
  499. }
  500.  
  501. =item constants (override)
  502.  
  503. Fixes up numerous file and directory macros to insure VMS syntax
  504. regardless of input syntax.  Also adds a few VMS-specific macros
  505. and makes lists of files comma-separated.
  506.  
  507. =cut
  508.  
  509. sub constants {
  510.     my($self) = @_;
  511.     my(@m,$def,$macro);
  512.  
  513.     if ($self->{DEFINE} ne '') {
  514.     my(@defs) = split(/\s+/,$self->{DEFINE});
  515.     foreach $def (@defs) {
  516.         next unless $def;
  517.         $def =~ s/^-D//;
  518.         $def = "\"$def\"" if $def =~ /=/;
  519.     }
  520.     $self->{DEFINE} = join ',',@defs;
  521.     }
  522.  
  523.     if ($self->{OBJECT} =~ /\s/) {
  524.     $self->{OBJECT} =~ s/(\\)?\n+\s+/ /g;
  525.     $self->{OBJECT} = map($self->fixpath($_),split(/,?\s+/,$self->{OBJECT}));
  526.     }
  527.     $self->{LDFROM} = join(' ',map($self->fixpath($_),split(/,?\s+/,$self->{LDFROM})));
  528.  
  529.     if ($self->{'INC'} && $self->{INC} !~ m!/Include=!i) {
  530.     my(@val) = ( '/Include=(' );
  531.     my(@includes) = split(/\s+/,$self->{INC});
  532.     my($plural);
  533.     foreach (@includes) {
  534.         s/^-I//;
  535.         push @val,', ' if $plural++;
  536.         push @val,$self->fixpath($_,1);
  537.     }
  538.     $self->{INC} = join('',@val,')');
  539.     }
  540.  
  541.     # Fix up directory specs
  542.     $self->{ROOTEXT} = $self->{ROOTEXT} ? $self->fixpath($self->{ROOTEXT},1)
  543.                                         : '[]';
  544.     foreach $macro ( qw [
  545.             INST_BIN INST_SCRIPT INST_LIB INST_ARCHLIB INST_EXE INSTALLPRIVLIB
  546.             INSTALLARCHLIB INSTALLSCRIPT INSTALLBIN PERL_LIB PERL_ARCHLIB
  547.             PERL_INC PERL_SRC FULLEXT INST_MAN1DIR INSTALLMAN1DIR
  548.             INST_MAN3DIR INSTALLMAN3DIR INSTALLSITELIB INSTALLSITEARCH
  549.             SITELIBEXP SITEARCHEXP ] ) {
  550.     next unless defined $self->{$macro};
  551.     $self->{$macro} = $self->fixpath($self->{$macro},1);
  552.     }
  553.     $self->{PERL_VMS} = $self->catdir($self->{PERL_SRC},q(VMS))
  554.     if ($self->{PERL_SRC});
  555.                         
  556.  
  557.  
  558.     # Fix up file specs
  559.     foreach $macro ( qw[LIBPERL_A FIRST_MAKEFILE MAKE_APERL_FILE MYEXTLIB] ) {
  560.     next unless defined $self->{$macro};
  561.     $self->{$macro} = $self->fixpath($self->{$macro});
  562.     }
  563.  
  564.     foreach $macro (qw/
  565.           AR_STATIC_ARGS NAME DISTNAME NAME_SYM VERSION VERSION_SYM XS_VERSION
  566.           INST_BIN INST_EXE INST_LIB INST_ARCHLIB INST_SCRIPT PREFIX
  567.           INSTALLDIRS INSTALLPRIVLIB  INSTALLARCHLIB INSTALLSITELIB
  568.           INSTALLSITEARCH INSTALLBIN INSTALLSCRIPT PERL_LIB
  569.           PERL_ARCHLIB SITELIBEXP SITEARCHEXP LIBPERL_A MYEXTLIB
  570.           FIRST_MAKEFILE MAKE_APERL_FILE PERLMAINCC PERL_SRC PERL_VMS
  571.           PERL_INC PERL FULLPERL
  572.           / ) {
  573.     next unless defined $self->{$macro};
  574.     push @m, "$macro = $self->{$macro}\n";
  575.     }
  576.  
  577.  
  578.     push @m, q[
  579. VERSION_MACRO = VERSION
  580. DEFINE_VERSION = "$(VERSION_MACRO)=""$(VERSION)"""
  581. XS_VERSION_MACRO = XS_VERSION
  582. XS_DEFINE_VERSION = "$(XS_VERSION_MACRO)=""$(XS_VERSION)"""
  583.  
  584. MAKEMAKER = ],$self->catfile($self->{PERL_LIB},'ExtUtils','MakeMaker.pm'),qq[
  585. MM_VERSION = $ExtUtils::MakeMaker::VERSION
  586. MM_REVISION = $ExtUtils::MakeMaker::Revision
  587. MM_VMS_REVISION = $ExtUtils::MM_VMS::Revision
  588.  
  589. # FULLEXT = Pathname for extension directory (eg DBD/Oracle).
  590. # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT.
  591. # PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar)
  592. # DLBASE  = Basename part of dynamic library. May be just equal BASEEXT.
  593. ];
  594.  
  595.     for $tmp (qw/
  596.           FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT
  597.           LDFROM LINKTYPE
  598.           /    ) {
  599.     next unless defined $self->{$tmp};
  600.     push @m, "$tmp = $self->{$tmp}\n";
  601.     }
  602.  
  603.     for $tmp (qw/ XS MAN1PODS MAN3PODS PM /) {
  604.     next unless defined $self->{$tmp};
  605.     my(%tmp,$key);
  606.     for $key (keys %{$self->{$tmp}}) {
  607.         $tmp{$self->fixpath($key)} = $self->fixpath($self->{$tmp}{$key});
  608.     }
  609.     $self->{$tmp} = \%tmp;
  610.     }
  611.  
  612.     for $tmp (qw/ C O_FILES H /) {
  613.     next unless defined $self->{$tmp};
  614.     my(@tmp,$val);
  615.     for $val (@{$self->{$tmp}}) {
  616.         push(@tmp,$self->fixpath($val));
  617.     }
  618.     $self->{$tmp} = \@tmp;
  619.     }
  620.  
  621.     push @m,'
  622.  
  623. # Handy lists of source code files:
  624. XS_FILES = ',join(', ', sort keys %{$self->{XS}}),'
  625. C_FILES  = ',join(', ', @{$self->{C}}),'
  626. O_FILES  = ',join(', ', @{$self->{O_FILES}} ),'
  627. H_FILES  = ',join(', ', @{$self->{H}}),'
  628. MAN1PODS = ',join(', ', sort keys %{$self->{MAN1PODS}}),'
  629. MAN3PODS = ',join(', ', sort keys %{$self->{MAN3PODS}}),'
  630.  
  631. ';
  632.  
  633.     for $tmp (qw/
  634.           INST_MAN1DIR INSTALLMAN1DIR MAN1EXT INST_MAN3DIR INSTALLMAN3DIR MAN3EXT
  635.           /) {
  636.     next unless defined $self->{$tmp};
  637.     push @m, "$tmp = $self->{$tmp}\n";
  638.     }
  639.  
  640. push @m,"
  641. .SUFFIXES : \$(OBJ_EXT) .c .cpp .cxx .xs
  642.  
  643. # Here is the Config.pm that we are using/depend on
  644. CONFIGDEP = \$(PERL_ARCHLIB)Config.pm, \$(PERL_INC)config.h \$(VERSION_FROM)
  645.  
  646. # Where to put things:
  647. INST_LIBDIR = ",($self->{'INST_LIBDIR'} = $self->catdir($self->{INST_LIB},$self->{ROOTEXT})),"
  648. INST_ARCHLIBDIR = ",($self->{'INST_ARCHLIBDIR'} = $self->catdir($self->{INST_ARCHLIB},$self->{ROOTEXT})),"
  649.  
  650. INST_AUTODIR = ",($self->{'INST_AUTODIR'} = $self->catdir($self->{INST_LIB},'auto',$self->{FULLEXT})),'
  651. INST_ARCHAUTODIR = ',($self->{'INST_ARCHAUTODIR'} = $self->catdir($self->{INST_ARCHLIB},'auto',$self->{FULLEXT})),'
  652. ';
  653.  
  654.     if ($self->has_link_code()) {
  655.     push @m,'
  656. INST_STATIC = $(INST_ARCHAUTODIR)$(BASEEXT)$(LIB_EXT)
  657. INST_DYNAMIC = $(INST_ARCHAUTODIR)$(BASEEXT).$(DLEXT)
  658. INST_BOOT = $(INST_ARCHAUTODIR)$(BASEEXT).bs
  659. ';
  660.     } else {
  661.     push @m,'
  662. INST_STATIC =
  663. INST_DYNAMIC =
  664. INST_BOOT =
  665. EXPORT_LIST = $(BASEEXT).opt
  666. PERL_ARCHIVE = ',($ENV{'PERLSHR'} ? $ENV{'PERLSHR'} : 'Sys$Share:PerlShr.Exe'),'
  667. ';
  668.     }
  669.  
  670.     $self->{TO_INST_PM} = [ sort keys %{$self->{PM}} ];
  671.     $self->{PM_TO_BLIB} = [ %{$self->{PM}} ];
  672.     push @m,'
  673. TO_INST_PM = ',join(', ',@{$self->{TO_INST_PM}}),'
  674.  
  675. PM_TO_BLIB = ',join(', ',@{$self->{PM_TO_BLIB}}),'
  676. ';
  677.  
  678.     join('',@m);
  679. }
  680.  
  681. =item const_loadlibs (override)
  682.  
  683. Basically a stub which passes through library specfications provided
  684. by the caller.  Will be updated or removed when VMS support is added
  685. to ExtUtils::Liblist.
  686.  
  687. =cut
  688.  
  689. sub const_loadlibs{
  690.     my($self) = @_;
  691.     my (@m);
  692.     push @m, "
  693. # $self->{NAME} might depend on some other libraries.
  694. # (These comments may need revising:)
  695. #
  696. # Dependent libraries can be linked in one of three ways:
  697. #
  698. #  1.  (For static extensions) by the ld command when the perl binary
  699. #      is linked with the extension library. See EXTRALIBS below.
  700. #
  701. #  2.  (For dynamic extensions) by the ld command when the shared
  702. #      object is built/linked. See LDLOADLIBS below.
  703. #
  704. #  3.  (For dynamic extensions) by the DynaLoader when the shared
  705. #      object is loaded. See BSLOADLIBS below.
  706. #
  707. # EXTRALIBS =    List of libraries that need to be linked with when
  708. #        linking a perl binary which includes this extension
  709. #        Only those libraries that actually exist are included.
  710. #        These are written to a file and used when linking perl.
  711. #
  712. # LDLOADLIBS =    List of those libraries which can or must be linked into
  713. #        the shared library when created using ld. These may be
  714. #        static or dynamic libraries.
  715. #        LD_RUN_PATH is a colon separated list of the directories
  716. #        in LDLOADLIBS. It is passed as an environment variable to
  717. #        the process that links the shared library.
  718. #
  719. # BSLOADLIBS =    List of those libraries that are needed but can be
  720. #        linked in dynamically at run time on this platform.
  721. #        SunOS/Solaris does not need this because ld records
  722. #        the information (from LDLOADLIBS) into the object file.
  723. #        This list is used to create a .bs (bootstrap) file.
  724. #
  725. EXTRALIBS  = ",map($self->fixpath($_) . ' ',$self->{'EXTRALIBS'}),"
  726. BSLOADLIBS = ",map($self->fixpath($_) . ' ',$self->{'BSLOADLIBS'}),"
  727. LDLOADLIBS = ",map($self->fixpath($_) . ' ',$self->{'LDLOADLIBS'}),"\n";
  728.  
  729.     join('',@m);
  730. }
  731.  
  732. =item cflags (override)
  733.  
  734. Bypass shell script and produce qualifiers for CC directly (but warn
  735. user if a shell script for this extension exists).  Fold multiple
  736. /Defines into one, and do the same with /Includes, since some C
  737. compilers pay attention to only one instance of these qualifiers
  738. on the command line.
  739.  
  740. =cut
  741.  
  742. sub cflags {
  743.     my($self,$libperl) = @_;
  744.     my($quals) = $Config{'ccflags'};
  745.     my($name,$sys,@m);
  746.     my($optimize) = '/Optimize';
  747.  
  748.     ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ;
  749.     print STDOUT "Unix shell script ".$Config{"$self->{'BASEEXT'}_cflags"}.
  750.          " required to modify CC command for $self->{'BASEEXT'}\n"
  751.     if ($Config{$name});
  752.  
  753.     # Deal with $self->{DEFINE} here since some C compilers pay attention
  754.     # to only one /Define clause on command line, so we have to
  755.     # conflate the ones from $Config{'cc'} and $self->{DEFINE}
  756.     if ($quals =~ m:(.*)/define=\(?([^\(\/\)\s]+)\)?(.*)?:i) {
  757.     $quals = "$1/Define=($2," . ($self->{DEFINE} ? "$self->{DEFINE}," : '') .
  758.              "\$(DEFINE_VERSION),\$(XS_DEFINE_VERSION))$3";
  759.     }
  760.     else {
  761.     $quals .= '/Define=(' . ($self->{DEFINE} ? "$self->{DEFINE}," : '') .
  762.               '$(DEFINE_VERSION),$(XS_DEFINE_VERSION))';
  763.     }
  764.  
  765.     $libperl or $libperl = $self->{LIBPERL_A} || "libperl.olb";
  766.     if ($libperl =~ /libperl(\w+)\./i) {
  767.         my($type) = uc $1;
  768.         my(%map) = ( 'D'  => 'DEBUGGING', 'E' => 'EMBED', 'M' => 'MULTIPLICITY',
  769.                      'DE' => 'DEBUGGING,EMBED', 'DM' => 'DEBUGGING,MULTIPLICITY',
  770.                      'EM' => 'EMBED,MULTIPLICITY', 'DEM' => 'DEBUGGING,EMBED,MULTIPLICITY' );
  771.         $quals =~ s:/define=\(([^\)]+)\):/Define=($1,$map{$type}):i
  772.     }
  773.  
  774.     # Likewise with $self->{INC} and /Include
  775.     my($incstr) = '/Include=($(PERL_INC)';
  776.     if ($self->{'INC'}) {
  777.     my(@includes) = split(/\s+/,$self->{INC});
  778.     foreach (@includes) {
  779.         s/^-I//;
  780.         $incstr .= ', '.$self->fixpath($_,1);
  781.     }
  782.     }
  783.     if ($quals =~ m:(.*)/include=\(?([^\(\/\)\s]+)\)?(.*):i) {
  784.     $quals = "$1$incstr,$2)$3";
  785.     }
  786.     else { $quals .= "$incstr)"; }
  787.  
  788.     $optimize = '/Debug/NoOptimize'
  789.     if ($self->{OPTIMIZE} =~ /-g/ or $self->{OPTIMIZE} =~ m!/Debug!i);
  790.  
  791.     return $self->{CFLAGS} = qq{
  792. CCFLAGS = $quals
  793. OPTIMIZE = $optimize
  794. PERLTYPE =
  795. SPLIT =
  796. LARGE =
  797. };
  798. }
  799.  
  800. =item const_cccmd (override)
  801.  
  802. Adds directives to point C preprocessor to the right place when
  803. handling #include <sys/foo.h> directives.  Also constructs CC
  804. command line a bit differently than MM_Unix method.
  805.  
  806. =cut
  807.  
  808. sub const_cccmd {
  809.     my($self,$libperl) = @_;
  810.     my(@m);
  811.  
  812.     return $self->{CONST_CCCMD} if $self->{CONST_CCCMD};
  813.     return '' unless $self->needs_linking();
  814.     if ($Config{'vms_cc_type'} eq 'gcc') {
  815.         push @m,'
  816. .FIRST
  817.     ',$self->{NOECHO},'If F$TrnLnm("Sys").eqs."" Then Define/NoLog SYS GNU_CC_Include:[VMS]';
  818.     }
  819.     elsif ($Config{'vms_cc_type'} eq 'vaxc') {
  820.         push @m,'
  821. .FIRST
  822.     ',$self->{NOECHO},'If F$TrnLnm("Sys").eqs."" .and. F$TrnLnm("VAXC$Include").eqs."" Then Define/NoLog SYS Sys$Library
  823.     ',$self->{NOECHO},'If F$TrnLnm("Sys").eqs."" .and. F$TrnLnm("VAXC$Include").nes."" Then Define/NoLog SYS VAXC$Include';
  824.     }
  825.     else {
  826.         push @m,'
  827. .FIRST
  828.     ',$self->{NOECHO},'If F$TrnLnm("Sys").eqs."" .and. F$TrnLnm("DECC$System_Include").eqs."" Then Define/NoLog SYS ',
  829.         ($Config{'arch'} eq 'VMS_AXP' ? 'Sys$Library' : 'DECC$Library_Include'),'
  830.     ',$self->{NOECHO},'If F$TrnLnm("Sys").eqs."" .and. F$TrnLnm("DECC$System_Include").nes."" Then Define/NoLog SYS DECC$System_Include';
  831.     }
  832.  
  833.     push(@m, "\n\nCCCMD = $Config{'cc'} \$(CCFLAGS)\$(OPTIMIZE)\n");
  834.  
  835.     $self->{CONST_CCCMD} = join('',@m);
  836. }
  837.  
  838. =item pm_to_blib (override)
  839.  
  840. DCL I<still> accepts a maximum of 255 characters on a command
  841. line, so we write the (potentially) long list of file names
  842. to a temp file, then persuade Perl to read it instead of the
  843. command line to find args.
  844.  
  845. =cut
  846.  
  847. sub pm_to_blib {
  848.     my($self) = @_;
  849.     my($line,$from,$to,@m);
  850.     my($autodir) = $self->catdir('$(INST_LIB)','auto');
  851.     my(@files) = @{$self->{PM_TO_BLIB}};
  852.  
  853.     push @m, q{
  854. # As always, keep under DCL's 255-char limit
  855. pm_to_blib : $(TO_INST_PM)
  856.     },$self->{NOECHO},q{$(PERL) -e "print '},shift(@files),q{ },shift(@files),q{'" >.MM_tmp
  857. };
  858.  
  859.     $line = '';  # avoid uninitialized var warning
  860.     while ($from = shift(@files),$to = shift(@files)) {
  861.     $line .= " $from $to";
  862.     if (length($line) > 128) {
  863.         push(@m,"\t$self->{NOECHO}\$(PERL) -e \"print '$line'\" >>.MM_tmp\n");
  864.         $line = '';
  865.     }
  866.     }
  867.     push(@m,"\t$self->{NOECHO}\$(PERL) -e \"print '$line'\" >>.MM_tmp\n") if $line;
  868.  
  869.     push(@m,q[    $(PERL) "-I$(PERL_LIB)" "-MExtUtils::Install" -e "pm_to_blib({split(' ',<STDIN>)},'].$autodir.q[')" <.MM_tmp]);
  870.     push(@m,qq[
  871.     $self->{NOECHO}Delete/NoLog/NoConfirm .MM_tmp;
  872.     $self->{NOECHO}\$(TOUCH) pm_to_blib.ts
  873. ]);
  874.  
  875.     join('',@m);
  876. }
  877.  
  878. =item tool_autosplit (override)
  879.  
  880. Use VMS-style quoting on command line.
  881.  
  882. =cut
  883.  
  884. sub tool_autosplit{
  885.     my($self, %attribs) = @_;
  886.     my($asl) = "";
  887.     $asl = "\$AutoSplit::Maxlen=$attribs{MAXLEN};" if $attribs{MAXLEN};
  888.     q{
  889. # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
  890. AUTOSPLITFILE = $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e "use AutoSplit;}.$asl.q{ AutoSplit::autosplit($ARGV[0], $ARGV[1], 0, 1, 1) ;"
  891. };
  892. }
  893.  
  894. =item tool_sxubpp (override)
  895.  
  896. Use VMS-style quoting on xsubpp command line.
  897.  
  898. =cut
  899.  
  900. sub tool_xsubpp {
  901.     my($self) = @_;
  902.     return '' unless $self->needs_linking;
  903.     my($xsdir) = $self->catdir($self->{PERL_LIB},'ExtUtils');
  904.     # drop back to old location if xsubpp is not in new location yet
  905.     $xsdir = $self->catdir($self->{PERL_SRC},'ext') unless (-f $self->catfile($xsdir,'xsubpp'));
  906.     my(@tmdeps) = '$(XSUBPPDIR)typemap';
  907.     if( $self->{TYPEMAPS} ){
  908.     my $typemap;
  909.     foreach $typemap (@{$self->{TYPEMAPS}}){
  910.         if( ! -f  $typemap ){
  911.             warn "Typemap $typemap not found.\n";
  912.         }
  913.         else{
  914.             push(@tmdeps, $self->fixpath($typemap));
  915.         }
  916.     }
  917.     }
  918.     push(@tmdeps, "typemap") if -f "typemap";
  919.     my(@tmargs) = map("-typemap $_", @tmdeps);
  920.     if( exists $self->{XSOPT} ){
  921.     unshift( @tmargs, $self->{XSOPT} );
  922.     }
  923.  
  924.     my $xsubpp_version = $self->xsubpp_version($self->catfile($xsdir,'xsubpp'));
  925.  
  926.     # What are the correct thresholds for version 1 && 2 Paul?
  927.     if ( $xsubpp_version > 1.923 ){
  928.     $self->{XSPROTOARG} = '' unless defined $self->{XSPROTOARG};
  929.     } else {
  930.     if (defined $self->{XSPROTOARG} && $self->{XSPROTOARG} =~ /\-prototypes/) {
  931.         print STDOUT qq{Warning: This extension wants to pass the switch "-prototypes" to xsubpp.
  932.     Your version of xsubpp is $xsubpp_version and cannot handle this.
  933.     Please upgrade to a more recent version of xsubpp.
  934. };
  935.     } else {
  936.         $self->{XSPROTOARG} = "";
  937.     }
  938.     }
  939.  
  940.     "
  941. XSUBPPDIR = $xsdir
  942. XSUBPP = \$(PERL) \"-I\$(PERL_ARCHLIB)\" \"-I\$(PERL_LIB)\" \$(XSUBPPDIR)xsubpp
  943. XSPROTOARG = $self->{XSPROTOARG}
  944. XSUBPPDEPS = @tmdeps
  945. XSUBPPARGS = @tmargs
  946. ";
  947. }
  948.  
  949. =item xsubpp_version (override)
  950.  
  951. Test xsubpp exit status according to VMS rules ($sts & 1 ==> good)
  952. rather than Unix rules ($sts == 0 ==> good).
  953.  
  954. =cut
  955.  
  956. sub xsubpp_version
  957. {
  958.     my($self,$xsubpp) = @_;
  959.     my ($version) ;
  960.     return '' unless $self->needs_linking;
  961.  
  962.     # try to figure out the version number of the xsubpp on the system
  963.  
  964.     # first try the -v flag, introduced in 1.921 & 2.000a2
  965.  
  966.     my $command = "$self->{PERL} \"-I$self->{PERL_LIB}\" $xsubpp -v";
  967.     print "Running: $command\n" if $Verbose;
  968.     $version = `$command` ;
  969.     warn "Running '$command' exits with status " . $? unless ($? & 1);
  970.     chop $version ;
  971.  
  972.     return $1 if $version =~ /^xsubpp version (.*)/ ;
  973.  
  974.     # nope, then try something else
  975.  
  976.     my $counter = '000';
  977.     my ($file) = 'temp' ;
  978.     $counter++ while -e "$file$counter"; # don't overwrite anything
  979.     $file .= $counter;
  980.  
  981.     local(*F);
  982.     open(F, ">$file") or die "Cannot open file '$file': $!\n" ;
  983.     print F <<EOM ;
  984. MODULE = fred PACKAGE = fred
  985.  
  986. int
  987. fred(a)
  988.     int    a;
  989. EOM
  990.  
  991.     close F ;
  992.  
  993.     $command = "$self->{PERL} $xsubpp $file";
  994.     print "Running: $command\n" if $Verbose;
  995.     my $text = `$command` ;
  996.     warn "Running '$command' exits with status " . $? unless ($? & 1);
  997.     unlink $file ;
  998.  
  999.     # gets 1.2 -> 1.92 and 2.000a1
  1000.     return $1 if $text =~ /automatically by xsubpp version ([\S]+)\s*/  ;
  1001.  
  1002.     # it is either 1.0 or 1.1
  1003.     return 1.1 if $text =~ /^Warning: ignored semicolon/ ;
  1004.  
  1005.     # none of the above, so 1.0
  1006.     return "1.0" ;
  1007. }
  1008.  
  1009. =item tools_other (override)
  1010.  
  1011. Adds a few MM[SK] macros, and shortens some the installatin commands,
  1012. in order to stay under DCL's 255-character limit.  Also changes
  1013. EQUALIZE_TIMESTAMP to set revision date of target file to one second
  1014. later than source file, since MMK interprets precisely equal revision
  1015. dates for a source and target file as a sign that the target needs
  1016. to be updated.
  1017.  
  1018. =cut
  1019.  
  1020. sub tools_other {
  1021.     my($self) = @_;
  1022.     qq!
  1023. # Assumes \$(MMS) invokes MMS or MMK
  1024. # (It is assumed in some cases later that the default makefile name
  1025. # (Descrip.MMS for MM[SK]) is used.)
  1026. USEMAKEFILE = /Descrip=
  1027. USEMACROS = /Macro=(
  1028. MACROEND = )
  1029. MAKEFILE = Descrip.MMS
  1030. SHELL = Posix
  1031. TOUCH = $self->{TOUCH}
  1032. CHMOD = $self->{CHMOD}
  1033. CP = $self->{CP}
  1034. MV = $self->{MV}
  1035. RM_F  = $self->{RM_F}
  1036. RM_RF = $self->{RM_RF}
  1037. UMASK_NULL = $self->{UMASK_NULL}
  1038. NOOP = $self->{NOOP}
  1039. MKPATH = Create/Directory
  1040. EQUALIZE_TIMESTAMP = \$(PERL) -we "open F,qq{>\$ARGV[1]};close F;utime(0,(stat(\$ARGV[0]))[9]+1,\$ARGV[1])"
  1041. !. ($self->{PARENT} ? '' : 
  1042. qq!WARN_IF_OLD_PACKLIST = \$(PERL) -e "if (-f \$ARGV[0]){print qq[WARNING: Old package found (\$ARGV[0]); please check for collisions\\n]}"
  1043. MOD_INSTALL = \$(PERL) "-I\$(PERL_LIB)" "-MExtUtils::Install" -e "install({split(' ',<STDIN>)},1);"
  1044. DOC_INSTALL = \$(PERL) -e "\@ARGV=split('|',<STDIN>);print '=head3 ',scalar(localtime),': C<',shift,qq[>\\n\\n=over 4\\n\\n];while(\$key=shift && \$val=shift){print qq[=item *\\n\\nC<\$key: \$val>\\n\\n];}print qq[=back\\n\\n]"
  1045. UNINSTALL = \$(PERL) "-I\$(PERL_LIB)" "-MExtUtils::Install" -e "uninstall(\$ARGV[0],1);"
  1046. !);
  1047. }
  1048.  
  1049. =item dist (override)
  1050.  
  1051. Provide VMSish defaults for some values, then hand off to
  1052. default MM_Unix method.
  1053.  
  1054. =cut
  1055.  
  1056. sub dist {
  1057.     my($self, %attribs) = @_;
  1058.     $attribs{VERSION}      ||= $self->{VERSION_SYM};
  1059.     $attribs{ZIPFLAGS}     ||= '-Vu';
  1060.     $attribs{COMPRESS}     ||= 'gzip';
  1061.     $attribs{SUFFIX}       ||= '-gz';
  1062.     $attribs{SHAR}         ||= 'vms_share';
  1063.     $attribs{DIST_DEFAULT} ||= 'zipdist';
  1064.  
  1065.     return ExtUtils::MM_Unix::dist($self,%attribs);
  1066. }
  1067.  
  1068. =item c_o (override)
  1069.  
  1070. Use VMS syntax on command line.  In particular, $(DEFINE) and
  1071. $(PERL_INC) have been pulled into $(CCCMD).  Also use MM[SK] macros.
  1072.  
  1073. =cut
  1074.  
  1075. sub c_o {
  1076.     my($self) = @_;
  1077.     return '' unless $self->needs_linking();
  1078.     '
  1079. .c$(OBJ_EXT) :
  1080.     $(CCCMD) $(CCCDLFLAGS) $(MMS$TARGET_NAME).c
  1081.  
  1082. .cpp$(OBJ_EXT) :
  1083.     $(CCCMD) $(CCCDLFLAGS) $(MMS$TARGET_NAME).cpp
  1084.  
  1085. .cxx$(OBJ_EXT) :
  1086.     $(CCCMD) $(CCCDLFLAGS) $(MMS$TARGET_NAME).cxx
  1087.  
  1088. ';
  1089. }
  1090.  
  1091. =item xs_c (override)
  1092.  
  1093. Use MM[SK] macros.
  1094.  
  1095. =cut
  1096.  
  1097. sub xs_c {
  1098.     my($self) = @_;
  1099.     return '' unless $self->needs_linking();
  1100.     '
  1101. .xs.c :
  1102.     $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $(MMS$TARGET_NAME).xs >$(MMS$TARGET)
  1103. ';
  1104. }
  1105.  
  1106. =item xs_o (override)
  1107.  
  1108. Use MM[SK] macros, and VMS command line for C compiler.
  1109.  
  1110. =cut
  1111.  
  1112. sub xs_o {    # many makes are too dumb to use xs_c then c_o
  1113.     my($self) = @_;
  1114.     return '' unless $self->needs_linking();
  1115.     '
  1116. .xs$(OBJ_EXT) :
  1117.     $(XSUBPP) $(XSPROTOARG) $(XSUBPPARGS) $(MMS$TARGET_NAME).xs >$(MMS$TARGET_NAME).c
  1118.     $(CCCMD) $(CCCDLFLAGS) $(MMS$TARGET_NAME).c
  1119. ';
  1120. }
  1121.  
  1122. =item top_targets (override)
  1123.  
  1124. Use VMS quoting on command line for Version_check.
  1125.  
  1126. =cut
  1127.  
  1128. sub top_targets {
  1129.     my($self) = shift;
  1130.     my(@m);
  1131.     push @m, '
  1132. all :: pure_all manifypods
  1133.     $(NOOP)
  1134.  
  1135. pure_all :: config pm_to_blib subdirs linkext
  1136.     $(NOOP)
  1137.  
  1138. subdirs :: $(MYEXTLIB)
  1139.     $(NOOP)
  1140.  
  1141. config :: $(MAKEFILE) $(INST_LIBDIR).exists
  1142.     $(NOOP)
  1143.  
  1144. config :: $(INST_ARCHAUTODIR).exists
  1145.     $(NOOP)
  1146.  
  1147. config :: $(INST_AUTODIR).exists
  1148.     $(NOOP)
  1149. ';
  1150.  
  1151.     push @m, q{
  1152. config :: Version_check
  1153.     $(NOOP)
  1154.  
  1155. } unless $self->{PARENT} or ($self->{PERL_SRC} && $self->{INSTALLDIRS} eq "perl") or $self->{NO_VC};
  1156.  
  1157.  
  1158.     push @m, $self->dir_target(qw[$(INST_AUTODIR) $(INST_LIBDIR) $(INST_ARCHAUTODIR)]);
  1159.     if (%{$self->{MAN1PODS}}) {
  1160.     push @m, q[
  1161. config :: $(INST_MAN1DIR).exists
  1162.     $(NOOP)
  1163. ];
  1164.     push @m, $self->dir_target(qw[$(INST_MAN1DIR)]);
  1165.     }
  1166.     if (%{$self->{MAN3PODS}}) {
  1167.     push @m, q[
  1168. config :: $(INST_MAN3DIR).exists
  1169.     $(NOOP)
  1170. ];
  1171.     push @m, $self->dir_target(qw[$(INST_MAN3DIR)]);
  1172.     }
  1173.  
  1174.     push @m, '
  1175. $(O_FILES) : $(H_FILES)
  1176. ' if @{$self->{O_FILES} || []} && @{$self->{H} || []};
  1177.  
  1178.     push @m, q{
  1179. help :
  1180.     perldoc ExtUtils::MakeMaker
  1181. };
  1182.  
  1183.     push @m, q{
  1184. Version_check :
  1185.     },$self->{NOECHO},q{$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -
  1186.     "-MExtUtils::MakeMaker=Version_check" -e "&Version_check('$(MM_VERSION)')"
  1187. };
  1188.  
  1189.     join('',@m);
  1190. }
  1191.  
  1192. =item dlsyms (override)
  1193.  
  1194. Create VMS linker options files specifying universal symbols for this
  1195. extension's shareable image, and listing other shareable images or 
  1196. libraries to which it should be linked.
  1197.  
  1198. =cut
  1199.  
  1200. sub dlsyms {
  1201.     my($self,%attribs) = @_;
  1202.  
  1203.     return '' unless $self->needs_linking();
  1204.  
  1205.     my($funcs) = $attribs{DL_FUNCS} || $self->{DL_FUNCS} || {};
  1206.     my($vars)  = $attribs{DL_VARS}  || $self->{DL_VARS}  || [];
  1207.     my($srcdir)= $attribs{PERL_SRC} || $self->{PERL_SRC} || '';
  1208.     my(@m);
  1209.  
  1210.     unless ($self->{SKIPHASH}{'dynamic'}) {
  1211.     push(@m,'
  1212. dynamic :: rtls.opt $(INST_ARCHAUTODIR)$(BASEEXT).opt
  1213.     $(NOOP)
  1214. ');
  1215.     if ($srcdir) {
  1216.        my($popt) = $self->catfile($srcdir,'perlshr.opt');
  1217.        my($lopt) = $self->catfile($srcdir,'crtl.opt');
  1218.        push(@m,"# Depend on $(BASEEXT).opt to insure we copy here *after* autogenerating (wrong) rtls.opt in Mksymlists
  1219. rtls.opt : $popt $lopt \$(BASEEXT).opt
  1220.     Copy/Log $popt Sys\$Disk:[]rtls.opt
  1221.     Append/Log $lopt Sys\$Disk:[]rtls.opt
  1222. ");
  1223.     }
  1224.     else {
  1225.         push(@m,'
  1226. # rtls.opt is built in the same step as $(BASEEXT).opt
  1227. rtls.opt : $(BASEEXT).opt
  1228.     $(TOUCH) $(MMS$TARGET)
  1229. ');
  1230.     }
  1231.     }
  1232.  
  1233.     push(@m,'
  1234. static :: $(INST_ARCHAUTODIR)$(BASEEXT).opt
  1235.     $(NOOP)
  1236. ') unless $self->{SKIPHASH}{'static'};
  1237.  
  1238.     push(@m,'
  1239. $(INST_ARCHAUTODIR)$(BASEEXT).opt : $(BASEEXT).opt
  1240.     $(CP) $(MMS$SOURCE) $(MMS$TARGET)
  1241.  
  1242. $(BASEEXT).opt : Makefile.PL
  1243.     $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e "use ExtUtils::Mksymlists;" -
  1244.     ',qq[-e "Mksymlists('NAME' => '$self->{NAME}', 'DL_FUNCS' => ],
  1245.     neatvalue($funcs),q[, 'DL_VARS' => ],neatvalue($vars),')"
  1246.     $(PERL) -e "print ""$(INST_STATIC)/Include=$(BASEEXT)\n$(INST_STATIC)/Library\n"";" >>$(MMS$TARGET)
  1247. ');
  1248.  
  1249.     join('',@m);
  1250. }
  1251.  
  1252. =item dynamic_lib (override)
  1253.  
  1254. Use VMS Link command.
  1255.  
  1256. =cut
  1257.  
  1258. sub dynamic_lib {
  1259.     my($self, %attribs) = @_;
  1260.     return '' unless $self->needs_linking(); #might be because of a subdir
  1261.  
  1262.     return '' unless $self->has_link_code();
  1263.  
  1264.     my($otherldflags) = $attribs{OTHERLDFLAGS} || "";
  1265.     my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || "";
  1266.     my(@m);
  1267.     push @m,"
  1268.  
  1269. OTHERLDFLAGS = $otherldflags
  1270. INST_DYNAMIC_DEP = $inst_dynamic_dep
  1271.  
  1272. ";
  1273.     push @m, '
  1274. $(INST_DYNAMIC) : $(INST_STATIC) $(PERL_INC)perlshr_attr.opt rtls.opt $(INST_ARCHAUTODIR).exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(INST_DYNAMIC_DEP)
  1275.     ',$self->{NOECHO},'$(MKPATH) $(INST_ARCHAUTODIR)
  1276.     Link $(LDFLAGS) /Shareable=$(MMS$TARGET)$(OTHERLDFLAGS) $(BASEEXT).opt/Option,rtls.opt/Option,$(PERL_INC)perlshr_attr.opt/Option
  1277. ';
  1278.  
  1279.     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
  1280.     join('',@m);
  1281. }
  1282.  
  1283. =item dynamic_bs (override)
  1284.  
  1285. Use VMS-style quoting on Mkbootstrap command line.
  1286.  
  1287. =cut
  1288.  
  1289. sub dynamic_bs {
  1290.     my($self, %attribs) = @_;
  1291.     return '
  1292. BOOTSTRAP =
  1293. ' unless $self->has_link_code();
  1294.     '
  1295. BOOTSTRAP = '."$self->{BASEEXT}.bs".'
  1296.  
  1297. # As MakeMaker mkbootstrap might not write a file (if none is required)
  1298. # we use touch to prevent make continually trying to remake it.
  1299. # The DynaLoader only reads a non-empty file.
  1300. $(BOOTSTRAP) : $(MAKEFILE) '."$self->{BOOTDEP}".' $(INST_ARCHAUTODIR).exists
  1301.     '.$self->{NOECHO}.'Write Sys$Output "Running mkbootstrap for $(NAME) ($(BSLOADLIBS))"
  1302.     '.$self->{NOECHO}.'$(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -
  1303.     -e "use ExtUtils::Mkbootstrap; Mkbootstrap(\'$(BASEEXT)\',\'$(BSLOADLIBS)\');"
  1304.     '.$self->{NOECHO}.' $(TOUCH) $(MMS$TARGET)
  1305.  
  1306. $(INST_BOOT) : $(BOOTSTRAP) $(INST_ARCHAUTODIR).exists
  1307.     '.$self->{NOECHO}.'$(RM_RF) $(INST_BOOT)
  1308.     - $(CP) $(BOOTSTRAP) $(INST_BOOT)
  1309. ';
  1310. }
  1311.  
  1312. =item static_lib (override)
  1313.  
  1314. Use VMS commands to manipulate object library.
  1315.  
  1316. =cut
  1317.  
  1318. sub static_lib {
  1319.     my($self) = @_;
  1320.     return '' unless $self->needs_linking();
  1321.  
  1322.     return '
  1323. $(INST_STATIC) :
  1324.     $(NOOP)
  1325. ' unless ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB});
  1326.  
  1327.     my(@m);
  1328.     push @m,'
  1329. # Rely on suffix rule for update action
  1330. $(OBJECT) : $(INST_ARCHAUTODIR).exists
  1331.  
  1332. $(INST_STATIC) : $(OBJECT) $(MYEXTLIB)
  1333. ';
  1334.     # If this extension has it's own library (eg SDBM_File)
  1335.     # then copy that to $(INST_STATIC) and add $(OBJECT) into it.
  1336.     push(@m, '    $(CP) $(MYEXTLIB) $(MMS$TARGET)',"\n") if $self->{MYEXTLIB};
  1337.  
  1338.     push(@m,'
  1339.     If F$Search("$(MMS$TARGET)").eqs."" Then Library/Object/Create $(MMS$TARGET)
  1340.     Library/Object/Replace $(MMS$TARGET) $(MMS$SOURCE_LIST)
  1341.     ',$self->{NOECHO},'$(PERL) -e "open F,\'>>$(INST_ARCHAUTODIR)extralibs.ld\';print F qq[$(EXTRALIBS)\n];close F;"
  1342. ');
  1343.     push @m, $self->dir_target('$(INST_ARCHAUTODIR)');
  1344.     join('',@m);
  1345. }
  1346.  
  1347.  
  1348. # sub installpm_x { # called by installpm perl file
  1349. #     my($self, $dist, $inst, $splitlib) = @_;
  1350. #     if ($inst =~ m!#!) {
  1351. #     warn "Warning: MM[SK] would have problems processing this file: $inst, SKIPPED\n";
  1352. #     return '';
  1353. #     }
  1354. #     $inst = $self->fixpath($inst);
  1355. #     $dist = $self->fixpath($dist);
  1356. #     my($instdir) = $inst =~ /([^\)]+\))[^\)]*$/ ? $1 : dirname($inst);
  1357. #     my(@m);
  1358. # 
  1359. #     push(@m, "
  1360. # $inst : $dist \$(MAKEFILE) ${instdir}.exists \$(INST_ARCHAUTODIR).exists
  1361. # ",'    ',$self->{NOECHO},'$(RM_F) $(MMS$TARGET)
  1362. #     ',$self->{NOECHO},'$(CP) ',"$dist $inst",'
  1363. #     $(CHMOD) 644 $(MMS$TARGET)
  1364. # ');
  1365. #     push(@m, '    $(AUTOSPLITFILE) $(MMS$TARGET) ',
  1366. #               $self->catdir($splitlib,'auto')."\n\n")
  1367. #         if ($splitlib and $inst =~ /\.pm$/);
  1368. #     push(@m,$self->dir_target($instdir));
  1369. # 
  1370. #     join('',@m);
  1371. # }
  1372.  
  1373. =item manifypods (override)
  1374.  
  1375. Use VMS-style quoting on command line, and VMS logical name
  1376. to specify fallback location at build time if we can't find pod2man.
  1377.  
  1378. =cut
  1379.  
  1380.  
  1381. sub manifypods {
  1382.     my($self, %attribs) = @_;
  1383.     return "\nmanifypods :\n\t\$(NOOP)\n" unless %{$self->{MAN3PODS}} or %{$self->{MAN1PODS}};
  1384.     my($dist);
  1385.     my($pod2man_exe);
  1386.     if (defined $self->{PERL_SRC}) {
  1387.     $pod2man_exe = $self->catfile($self->{PERL_SRC},'pod','pod2man');
  1388.     } else {
  1389.     $pod2man_exe = $self->catfile($Config{scriptdirexp},'pod2man');
  1390.     }
  1391.     if ($pod2man_exe = $self->perl_script($pod2man_exe)) { $found_pod2man = 1; }
  1392.     else {
  1393.     # No pod2man but some MAN3PODS to be installed
  1394.     print <<END;
  1395.  
  1396. Warning: I could not locate your pod2man program.  As a last choice,
  1397.          I will look for the file to which the logical name POD2MAN
  1398.          points when MMK is invoked.
  1399.  
  1400. END
  1401.         $pod2man_exe = "pod2man";
  1402.     }
  1403.     my(@m);
  1404.     push @m,
  1405. qq[POD2MAN_EXE = $pod2man_exe\n],
  1406. q[POD2MAN = $(PERL) -we "%m=@ARGV;for (keys %m){" -
  1407. -e "system(""MCR $^X $(POD2MAN_EXE) $_ >$m{$_}"");}"
  1408. ];
  1409.     push @m, "\nmanifypods : ";
  1410.     push @m, join " ", keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}};
  1411.     push(@m,"\n");
  1412.     if (%{$self->{MAN1PODS}} || %{$self->{MAN3PODS}}) {
  1413.     my($pod);
  1414.     foreach $pod (sort keys %{$self->{MAN1PODS}}) {
  1415.         push @m, qq[\t\@- If F\$Search("\$(POD2MAN_EXE)").nes."" Then \$(POD2MAN) ];
  1416.         push @m, "$pod $self->{MAN1PODS}{$pod}\n";
  1417.     }
  1418.     foreach $pod (sort keys %{$self->{MAN3PODS}}) {
  1419.         push @m, qq[\t\@- If F\$Search("\$(POD2MAN_EXE)").nes."" Then \$(POD2MAN) ];
  1420.         push @m, "$pod $self->{MAN3PODS}{$pod}\n";
  1421.     }
  1422.     }
  1423.     join('', @m);
  1424. }
  1425.  
  1426. =item processPL (override)
  1427.  
  1428. Use VMS-style quoting on command line.
  1429.  
  1430. =cut
  1431.  
  1432. sub processPL {
  1433.     my($self) = @_;
  1434.     return "" unless $self->{PL_FILES};
  1435.     my(@m, $plfile);
  1436.     foreach $plfile (sort keys %{$self->{PL_FILES}}) {
  1437.     push @m, "
  1438. all :: $self->{PL_FILES}->{$plfile}
  1439.     \$(NOOP)
  1440.  
  1441. $self->{PL_FILES}->{$plfile} :: $plfile
  1442. ",'    $(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" '," $plfile
  1443. ";
  1444.     }
  1445.     join "", @m;
  1446. }
  1447.  
  1448. =item installbin (override)
  1449.  
  1450. Stay under DCL's 255 character command line limit once again by
  1451. splitting potentially long list of files across multiple lines
  1452. in C<realclean> target.
  1453.  
  1454. =cut
  1455.  
  1456. sub installbin {
  1457.     my($self) = @_;
  1458.     return '' unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY";
  1459.     return '' unless @{$self->{EXE_FILES}};
  1460.     my(@m, $from, $to, %fromto, @to, $line);
  1461.     for $from (@{$self->{EXE_FILES}}) {
  1462.     my($path) = '$(INST_SCRIPT)' . basename($from);
  1463.     local($_) = $path;  # backward compatibility
  1464.     $to = $self->libscan($path);
  1465.     print "libscan($from) => '$to'\n" if ($Verbose >=2);
  1466.     $fromto{$from}=$to;
  1467.     }
  1468.     @to   = values %fromto;
  1469.     push @m, "
  1470. EXE_FILES = @{$self->{EXE_FILES}}
  1471.  
  1472. all :: @to
  1473.     \$(NOOP)
  1474.  
  1475. realclean ::
  1476. ";
  1477.     $line = '';  #avoid unitialized var warning
  1478.     foreach $to (@to) {
  1479.     if (length($line) + length($to) > 80) {
  1480.         push @m, "\t\$(RM_F) $line\n";
  1481.         $line = $to;
  1482.     }
  1483.     else { $line .= " $to"; }
  1484.     }
  1485.     push @m, "\t\$(RM_F) $line\n\n" if $line;
  1486.  
  1487.     while (($from,$to) = each %fromto) {
  1488.     last unless defined $from;
  1489.     my $todir;
  1490.     if ($to =~ m#[/>:\]]#) { $todir = dirname($to); }
  1491.     else                   { ($todir = $to) =~ s/[^\)]+$//; }
  1492.     $todir = $self->fixpath($todir,1);
  1493.     push @m, "
  1494. $to : $from \$(MAKEFILE) ${todir}.exists
  1495.     \$(CP) $from $to
  1496.  
  1497. ", $self->dir_target($todir);
  1498.     }
  1499.     join "", @m;
  1500. }
  1501.  
  1502. =item subdir_x (override)
  1503.  
  1504. Use VMS commands to change default directory.
  1505.  
  1506. =cut
  1507.  
  1508. sub subdir_x {
  1509.     my($self, $subdir) = @_;
  1510.     my(@m,$key);
  1511.     $subdir = $self->fixpath($subdir,1);
  1512.     push @m, '
  1513.  
  1514. subdirs ::
  1515.     olddef = F$Environment("Default")
  1516.     Set Default ',$subdir,'
  1517.     - $(MMS) all $(USEMACROS)$(PASTHRU)$(MACROEND)
  1518.     Set Default \'olddef\'
  1519. ';
  1520.     join('',@m);
  1521. }
  1522.  
  1523. =item clean (override)
  1524.  
  1525. Split potentially long list of files across multiple commands (in
  1526. order to stay under the magic command line limit).  Also use MM[SK]
  1527. commands for handling subdirectories.
  1528.  
  1529. =cut
  1530.  
  1531. sub clean {
  1532.     my($self, %attribs) = @_;
  1533.     my(@m,$dir);
  1534.     push @m, '
  1535. # Delete temporary files but do not touch installed files. We don\'t delete
  1536. # the Descrip.MMS here so that a later make realclean still has it to use.
  1537. clean ::
  1538. ';
  1539.     foreach $dir (@{$self->{DIR}}) { # clean subdirectories first
  1540.     my($vmsdir) = $self->fixpath($dir,1);
  1541.     push( @m, '    If F$Search("'.$vmsdir.'$(MAKEFILE)") Then \\',"\n\t",
  1542.           '$(PERL) -e "chdir ',"'$vmsdir'",'; print `$(MMS) clean`;"',"\n");
  1543.     }
  1544.     push @m, '    $(RM_F) *.Map *.Dmp *.Lis *.cpp *.$(DLEXT) *$(OBJ_EXT) *$(LIB_EXT) *.Opt $(BOOTSTRAP) $(BASEEXT).bso
  1545. ';
  1546.  
  1547.     my(@otherfiles) = values %{$self->{XS}}; # .c files from *.xs files
  1548.     push(@otherfiles, $attribs{FILES}) if $attribs{FILES};
  1549.     push(@otherfiles, qw[ blib $(MAKE_APERL_FILE) extralibs.ld perlmain.c pm_to_blib.ts ]);
  1550.     push(@otherfiles,$self->catfile('$(INST_ARCHAUTODIR)','extralibs.all'));
  1551.     my($file,$line);
  1552.     $line = '';  #avoid unitialized var warning
  1553.     foreach $file (@otherfiles) {
  1554.     $file = $self->fixpath($file);
  1555.     if (length($line) + length($file) > 80) {
  1556.         push @m, "\t\$(RM_RF) $line\n";
  1557.         $line = "$file";
  1558.     }
  1559.     else { $line .= " $file"; }
  1560.     }
  1561.     push @m, "\t\$(RM_RF) $line\n" if line;
  1562.     push(@m, "    $attribs{POSTOP}\n") if $attribs{POSTOP};
  1563.     join('', @m);
  1564. }
  1565.  
  1566. =item realclean (override)
  1567.  
  1568. Guess what we're working around?  Also, use MM[SK] for subdirectories.
  1569.  
  1570. =cut
  1571.  
  1572. sub realclean {
  1573.     my($self, %attribs) = @_;
  1574.     my(@m);
  1575.     push(@m,'
  1576. # Delete temporary files (via clean) and also delete installed files
  1577. realclean :: clean
  1578. ');
  1579.     foreach(@{$self->{DIR}}){
  1580.     my($vmsdir) = $self->fixpath($_,1);
  1581.     push(@m, '    If F$Search("'."$vmsdir".'$(MAKEFILE)").nes."" Then \\',"\n\t",
  1582.           '$(PERL) -e "chdir ',"'$vmsdir'",'; print `$(MMS) realclean`;"',"\n");
  1583.     }
  1584.     push @m,'    $(RM_RF) $(INST_AUTODIR) $(INST_ARCHAUTODIR)
  1585. ';
  1586.     # We can't expand several of the MMS macros here, since they don't have
  1587.     # corresponding %$self keys (i.e. they're defined in Descrip.MMS as a
  1588.     # combination of macros).  In order to stay below DCL's 255 char limit,
  1589.     # we put only 2 on a line.
  1590.     my($file,$line,$fcnt);
  1591.     my(@files) = qw{ $(MAKEFILE) $(MAKEFILE)_old };
  1592.     if ($self->has_link_code) {
  1593.     push(@files,qw{ $(INST_DYNAMIC) $(INST_STATIC) $(INST_BOOT) $(OBJECT) });
  1594.     }
  1595.     push(@files, values %{$self->{PM}});
  1596.     $line = '';  #avoid unitialized var warning
  1597.     foreach $file (@files) {
  1598.     $file = $self->fixpath($file);
  1599.     if (length($line) + length($file) > 80 || ++$fcnt >= 2) {
  1600.         push @m, "\t\$(RM_F) $line\n";
  1601.         $line = "$file";
  1602.         $fcnt = 0;
  1603.     }
  1604.     else { $line .= " $file"; }
  1605.     }
  1606.     push @m, "\t\$(RM_F) $line\n" if $line;
  1607.     if ($attribs{FILES} && ref $attribs{FILES} eq 'ARRAY') {
  1608.     $line = '';
  1609.     foreach $file (@{$attribs{'FILES'}}) {
  1610.         $file = $self->fixpath($file);
  1611.         if (length($line) + length($file) > 80) {
  1612.         push @m, "\t\$(RM_RF) $line\n";
  1613.         $line = "$file";
  1614.         }
  1615.         else { $line .= " $file"; }
  1616.     }
  1617.     push @m, "\t\$(RM_RF) $line\n" if $line;
  1618.     }
  1619.     push(@m, "    $attribs{POSTOP}\n")                     if $attribs{POSTOP};
  1620.     join('', @m);
  1621. }
  1622.  
  1623. =item dist_basics (override)
  1624.  
  1625. Use VMS-style quoting on command line.
  1626.  
  1627. =cut
  1628.  
  1629. sub dist_basics {
  1630.     my($self) = @_;
  1631. '
  1632. distclean :: realclean distcheck
  1633.     $(NOOP)
  1634.  
  1635. distcheck :
  1636.     $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e "use ExtUtils::Manifest \'&fullcheck\'; fullcheck()"
  1637.  
  1638. skipcheck :
  1639.     $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e "use ExtUtils::Manifest \'&fullcheck\'; skipcheck()"
  1640.  
  1641. manifest :
  1642.     $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e "use ExtUtils::Manifest \'&mkmanifest\'; mkmanifest()"
  1643. ';
  1644. }
  1645.  
  1646. =item dist_core (override)
  1647.  
  1648. Syntax for invoking F<VMS_Share> differs from that for Unix F<shar>,
  1649. so C<shdist> target actions are VMS-specific.
  1650.  
  1651. =cut
  1652.  
  1653. sub dist_core {
  1654.     my($self) = @_;
  1655. q[
  1656. dist : $(DIST_DEFAULT)
  1657.     ].$self->{NOECHO}.q[$(PERL) -le "print 'Warning: $m older than $vf' if -e ($vf = '$(VERSION_FROM)') && -M $vf < -M ($m = '$(MAKEFILE)'"
  1658.  
  1659. zipdist : $(DISTVNAME).zip
  1660.     $(NOOP)
  1661.  
  1662. $(DISTVNAME).zip : distdir
  1663.     $(PREOP)
  1664.     $(ZIP) "$(ZIPFLAGS)" $(MMS$TARGET) $(SRC)
  1665.     $(RM_RF) $(DISTVNAME)
  1666.     $(POSTOP)
  1667.  
  1668. $(DISTVNAME).tar$(SUFFIX) : distdir
  1669.     $(PREOP)
  1670.     $(TO_UNIX)
  1671.     $(TAR) "$(TARFLAGS)" $(DISTVNAME).tar $(SRC)
  1672.     $(RM_RF) $(DISTVNAME)
  1673.     $(COMPRESS) $(DISTVNAME).tar
  1674.     $(POSTOP)
  1675.  
  1676. shdist : distdir
  1677.     $(PREOP)
  1678.     $(SHARE) $(SRC) $(DISTVNAME).share
  1679.     $(RM_RF) $(DISTVNAME)
  1680.     $(POSTOP)
  1681. ];
  1682. }
  1683.  
  1684. =item dist_dir (override)
  1685.  
  1686. Use VMS-style quoting on command line.
  1687.  
  1688. =cut
  1689.  
  1690. sub dist_dir {
  1691.     my($self) = @_;
  1692. q{
  1693. distdir :
  1694.     $(RM_RF) $(DISTVNAME)
  1695.     $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" -e "use ExtUtils::Manifest '/mani/';" \\
  1696.     -e "manicopy(maniread(),'$(DISTVNAME)','$(DIST_CP)');"
  1697. };
  1698. }
  1699.  
  1700. =item dist_test (override)
  1701.  
  1702. Use VMS commands to change default directory, and use VMS-style
  1703. quoting on command line.
  1704.  
  1705. =cut
  1706.  
  1707. sub dist_test {
  1708.     my($self) = @_;
  1709. q{
  1710. disttest : distdir
  1711.     startdir = F$Environment("Default")
  1712.     Set Default [.$(DISTVNAME)]
  1713.     $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL
  1714.     $(MMS)
  1715.     $(MMS) test
  1716.     Set Default 'startdir'
  1717. };
  1718. }
  1719.  
  1720. # --- Test and Installation Sections ---
  1721.  
  1722. =item install (override)
  1723.  
  1724. Work around DCL's 255 character limit several times,and use
  1725. VMS-style command line quoting in a few cases.
  1726.  
  1727. =cut
  1728.  
  1729. sub install {
  1730.     my($self, %attribs) = @_;
  1731.     my(@m,@docfiles);
  1732.  
  1733.     if ($self->{EXE_FILES}) {
  1734.     my($line,$file) = ('','');
  1735.     foreach $file (@{$self->{EXE_FILES}}) {
  1736.         $line .= "$file ";
  1737.         if (length($line) > 128) {
  1738.         push(@docfiles,qq[\t\$(PERL) -e "print $line" >>.MM_tmp\n]);
  1739.         $line = '';
  1740.         }
  1741.     }
  1742.     push(@docfiles,qq[\t\$(PERL) -e "print $line" >>.MM_tmp\n]) if $line;
  1743.     }
  1744.  
  1745.     push @m, q[
  1746. install :: all pure_install doc_install
  1747.     $(NOOP)
  1748.  
  1749. install_perl :: all pure_perl_install doc_perl_install
  1750.     $(NOOP)
  1751.  
  1752. install_site :: all pure_site_install doc_site_install
  1753.     $(NOOP)
  1754.  
  1755. install_ :: install_site
  1756.     ],$self->{NOECHO},q[Write Sys$Output "INSTALLDIRS not defined, defaulting to INSTALLDIRS=site"
  1757.  
  1758. pure_install :: pure_$(INSTALLDIRS)_install
  1759.     $(NOOP)
  1760.  
  1761. doc_install :: doc_$(INSTALLDIRS)_install
  1762.     ],$self->{NOECHO},q[Write Sys$Output "Appending installation info to $(INST_ARCHLIB)perllocal.pod"
  1763.  
  1764. pure__install : pure_site_install
  1765.     ],$self->{NOECHO},q[Write Sys$Output "INSTALLDIRS not defined, defaulting to INSTALLDIRS=site"
  1766.  
  1767. doc__install : doc_site_install
  1768.     ],$self->{NOECHO},q[Write Sys$Output "INSTALLDIRS not defined, defaulting to INSTALLDIRS=site"
  1769.  
  1770. # This hack brought to you by DCL's 255-character command line limit
  1771. pure_perl_install ::
  1772.     ].$self->{NOECHO}.q[$(PERL) -e "print 'read ].$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q[ '" >.MM_tmp
  1773.     ].$self->{NOECHO}.q[$(PERL) -e "print 'write ].$self->catfile('$(INSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q[ '" >>.MM_tmp
  1774.     ].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_LIB) $(INSTALLPRIVLIB) '" >>.MM_tmp
  1775.     ].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_ARCHLIB) $(INSTALLARCHLIB) '" >>.MM_tmp
  1776.     ].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_BIN) $(INSTALLBIN) '" >>.MM_tmp
  1777.     ].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_SCRIPT) $(INSTALLSCRIPT) '" >>.MM_tmp
  1778.     ].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_MAN1DIR) $(INSTALLMAN1DIR) '" >>.MM_tmp
  1779.     ].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_MAN3DIR) $(INSTALLMAN3DIR) '" >>.MM_tmp
  1780.     $(MOD_INSTALL) <.MM_tmp
  1781.     ].$self->{NOECHO}.q[Delete/NoLog/NoConfirm .MM_tmp;
  1782.     ].$self->{NOECHO}.q[$(WARN_IF_OLD_PACKLIST) ].$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q[
  1783.  
  1784. # Likewise
  1785. pure_site_install ::
  1786.     ].$self->{NOECHO}.q[$(PERL) -e "print 'read ].$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q[ '" >.MM_tmp
  1787.     ].$self->{NOECHO}.q[$(PERL) -e "print 'write ].$self->catfile('$(INSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q[ '" >>.MM_tmp
  1788.     ].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_LIB) $(INSTALLSITELIB) '" >>.MM_tmp
  1789.     ].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_ARCHLIB) $(INSTALLSITEARCH) '" >>.MM_tmp
  1790.     ].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_BIN) $(INSTALLBIN) '" >>.MM_tmp
  1791.     ].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_SCRIPT) $(INSTALLSCRIPT) '" >>.MM_tmp
  1792.     ].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_MAN1DIR) $(INSTALLMAN1DIR) '" >>.MM_tmp
  1793.     ].$self->{NOECHO}.q[$(PERL) -e "print '$(INST_MAN3DIR) $(INSTALLMAN3DIR) '" >>.MM_tmp
  1794.     $(MOD_INSTALL) <.MM_tmp
  1795.     ].$self->{NOECHO}.q[Delete/NoLog/NoConfirm .MM_tmp;
  1796.     ].$self->{NOECHO}.q[$(WARN_IF_OLD_PACKLIST) ].$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q[
  1797.  
  1798. # Ditto
  1799. doc_perl_install ::
  1800.     ].$self->{NOECHO}.q[$(PERL) -e "print 'Module $(NAME)|installed into|$(INSTALLPRIVLIB)|'" >.MM_tmp
  1801.     ].$self->{NOECHO}.q[$(PERL) -e "print 'LINKTYPE|$(LINKTYPE)|VERSION|$(VERSION)|'" >>.MM_tmp
  1802.     ].$self->{NOECHO}.q[$(PERL) -e "print 'LINKTYPE|$(LINKTYPE)|VERSION|$(VERSION)|EXE_FILES|'" >>.MM_tmp
  1803. ],@docfiles,q[    $(DOC_INSTALL) <.MM_tmp >>].$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q[
  1804.     ].$self->{NOECHO}.q[Delete/NoLog/NoConfirm .MM_tmp;
  1805.  
  1806. # And again
  1807. doc_site_install ::
  1808.     ].$self->{NOECHO}.q[$(PERL) -e "print 'Module $(NAME)|installed into|$(INSTALLSITELIB)|'" >.MM_tmp
  1809.     ].$self->{NOECHO}.q[$(PERL) -e "print 'LINKTYPE|$(LINKTYPE)|VERSION|$(VERSION)|'" >>.MM_tmp
  1810.     ].$self->{NOECHO}.q[$(PERL) -e "print 'LINKTYPE|$(LINKTYPE)|VERSION|$(VERSION)|EXE_FILES|'" >>.MM_tmp
  1811. ],@docfiles,q[    $(DOC_INSTALL) <.MM_tmp >>].$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q[
  1812.     ].$self->{NOECHO}.q[Delete/NoLog/NoConfirm .MM_tmp;
  1813.  
  1814. ];
  1815.  
  1816.     push @m, q[
  1817. uninstall :: uninstall_from_$(INSTALLDIRS)dirs
  1818.     $(NOOP)
  1819.  
  1820. uninstall_from_perldirs ::
  1821.     ].$self->{NOECHO}.q[$(UNINSTALL) ].$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q[
  1822.  
  1823. uninstall_from_sitedirs ::
  1824.     ].$self->{NOECHO}.q[$(UNINSTALL) ].$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist')."\n";
  1825.  
  1826.     join('',@m);
  1827. }
  1828.  
  1829. =item perldepend (override)
  1830.  
  1831. Use VMS-style syntax for files; it's cheaper to just do it directly here
  1832. than to have the MM_Unix method call C<catfile> repeatedly.  Also use
  1833. config.vms as source of original config data if the Perl distribution
  1834. is available; config.sh is an ancillary file under VMS.  Finally, if
  1835. we have to rebuild Config.pm, use MM[SK] to do it.
  1836.  
  1837. =cut
  1838.  
  1839. sub perldepend {
  1840.     my($self) = @_;
  1841.     my(@m);
  1842.  
  1843.     push @m, '
  1844. $(OBJECT) : $(PERL_INC)EXTERN.h, $(PERL_INC)INTERN.h, $(PERL_INC)XSUB.h, $(PERL_INC)av.h
  1845. $(OBJECT) : $(PERL_INC)cop.h, $(PERL_INC)cv.h, $(PERL_INC)embed.h, $(PERL_INC)form.h
  1846. $(OBJECT) : $(PERL_INC)gv.h, $(PERL_INC)handy.h, $(PERL_INC)hv.h, $(PERL_INC)keywords.h
  1847. $(OBJECT) : $(PERL_INC)mg.h, $(PERL_INC)op.h, $(PERL_INC)opcode.h, $(PERL_INC)patchlevel.h
  1848. $(OBJECT) : $(PERL_INC)perl.h, $(PERL_INC)perly.h, $(PERL_INC)pp.h, $(PERL_INC)proto.h
  1849. $(OBJECT) : $(PERL_INC)regcomp.h, $(PERL_INC)regexp.h, $(PERL_INC)scope.h, $(PERL_INC)sv.h
  1850. $(OBJECT) : $(PERL_INC)vmsish.h, $(PERL_INC)util.h, $(PERL_INC)config.h
  1851.  
  1852. ' if $self->{OBJECT}; 
  1853.  
  1854.     if ($self->{PERL_SRC}) {
  1855.     my(@macros);
  1856.     my($mmsquals) = '$(USEMAKEFILE)[.vms]$(MAKEFILE)';
  1857.     push(@macros,'__AXP__=1') if $Config{'arch'} eq 'VMS_AXP';
  1858.     push(@macros,'DECC=1')    if $Config{'vms_cc_type'} eq 'decc';
  1859.     push(@macros,'GNUC=1')    if $Config{'vms_cc_type'} eq 'gcc';
  1860.     push(@macros,'SOCKET=1')  if $Config{'d_has_sockets'};
  1861.     push(@macros,qq["CC=$Config{'cc'}"])  if $Config{'cc'} =~ m!/!;
  1862.     $mmsquals .= '$(USEMACROS)' . join(',',@macros) . '$(MACROEND)' if @macros;
  1863.     push(@m,q[
  1864. # Check for unpropagated config.sh changes. Should never happen.
  1865. # We do NOT just update config.h because that is not sufficient.
  1866. # An out of date config.h is not fatal but complains loudly!
  1867. #$(PERL_INC)config.h : $(PERL_SRC)config.sh
  1868. $(PERL_INC)config.h : $(PERL_VMS)config.vms
  1869.     ],$self->{NOECHO},q[Write Sys$Error "Warning: $(PERL_INC)config.h out of date with $(PERL_VMS)config.vms"
  1870.  
  1871. #$(PERL_ARCHLIB)Config.pm : $(PERL_SRC)config.sh
  1872. $(PERL_ARCHLIB)Config.pm : $(PERL_VMS)config.vms $(PERL_VMS)genconfig.pl
  1873.     ],$self->{NOECHO},q[Write Sys$Error "$(PERL_ARCHLIB)Config.pm may be out of date with config.vms or genconfig.pl"
  1874.     olddef = F$Environment("Default")
  1875.     Set Default $(PERL_SRC)
  1876.     $(MMS)],$mmsquals,q[ $(MMS$TARGET)
  1877.     Set Default 'olddef'
  1878. ]);
  1879.     }
  1880.  
  1881.     push(@m, join(" ", map($self->fixpath($_),values %{$self->{XS}}))." : \$(XSUBPPDEPS)\n")
  1882.       if %{$self->{XS}};
  1883.  
  1884.     join('',@m);
  1885. }
  1886.  
  1887. =item makefile (override)
  1888.  
  1889. Use VMS commands and quoting.
  1890.  
  1891. =cut
  1892.  
  1893. sub makefile {
  1894.     my($self) = @_;
  1895.     my(@m,@cmd);
  1896.     # We do not know what target was originally specified so we
  1897.     # must force a manual rerun to be sure. But as it should only
  1898.     # happen very rarely it is not a significant problem.
  1899.     push @m, q[
  1900. $(OBJECT) : $(FIRST_MAKEFILE)
  1901. ] if $self->{OBJECT};
  1902.  
  1903.     push @m,q[
  1904. # We take a very conservative approach here, but it\'s worth it.
  1905. # We move $(MAKEFILE) to $(MAKEFILE)_old here to avoid gnu make looping.
  1906. $(MAKEFILE) : Makefile.PL $(CONFIGDEP)
  1907.     ],$self->{NOECHO},q[Write Sys$Output "$(MAKEFILE) out-of-date with respect to $(MMS$SOURCE_LIST)"
  1908.     ],$self->{NOECHO},q[Write Sys$Output "Cleaning current config before rebuilding $(MAKEFILE) ..."
  1909.     - $(MV) $(MAKEFILE) $(MAKEFILE)_old
  1910.     - $(MMS) $(USEMAKEFILE)$(MAKEFILE)_old clean
  1911.     $(PERL) "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" Makefile.PL ],join(' ',map(qq["$_"],@ARGV)),q[
  1912.     ],$self->{NOECHO},q[Write Sys$Output "$(MAKEFILE) has been rebuilt."
  1913.     ],$self->{NOECHO},q[Write Sys$Output "Please run $(MMS) to build the extension."
  1914. ];
  1915.  
  1916.     join('',@m);
  1917. }
  1918.  
  1919. =item test (override)
  1920.  
  1921. Use VMS commands for handling subdirectories.
  1922.  
  1923. =cut
  1924.  
  1925. sub test {
  1926.     my($self, %attribs) = @_;
  1927.     my($tests) = $attribs{TESTS} || ( -d 't' ? 't/*.t' : '');
  1928.     my(@m);
  1929.     push @m,"
  1930. TEST_VERBOSE = 0
  1931. TEST_TYPE = test_\$(LINKTYPE)
  1932. TEST_FILE = test.pl
  1933. TESTDB_SW = -d
  1934.  
  1935. test :: \$(TEST_TYPE)
  1936.     \$(NOOP)
  1937.  
  1938. testdb :: testdb_\$(LINKTYPE)
  1939.     \$(NOOP)
  1940.  
  1941. ";
  1942.     foreach(@{$self->{DIR}}){
  1943.       my($vmsdir) = $self->fixpath($_,1);
  1944.       push(@m, '    If F$Search("',$vmsdir,'$(MAKEFILE)").nes."" Then $(PERL) -e "chdir ',"'$vmsdir'",
  1945.            '; print `$(MMS) $(PASTHRU2) test`'."\n");
  1946.     }
  1947.     push(@m, "\t$self->{NOECHO}Write Sys\$Output \"No tests defined for \$(NAME) extension.\"\n")
  1948.         unless $tests or -f "test.pl" or @{$self->{DIR}};
  1949.     push(@m, "\n");
  1950.  
  1951.     push(@m, "test_dynamic :: pure_all\n");
  1952.     push(@m, $self->test_via_harness('$(FULLPERL)', $tests)) if $tests;
  1953.     push(@m, $self->test_via_script('$(FULLPERL)', 'test.pl')) if -f "test.pl";
  1954.     push(@m, "    \$(NOOP)\n") if (!$tests && ! -f "test.pl");
  1955.     push(@m, "\n");
  1956.  
  1957.     push(@m, "testdb_dynamic :: pure_all\n");
  1958.     push(@m, $self->test_via_script('$(FULLPERL) "$(TESTDB_SW)"', '$(TEST_FILE)'));
  1959.     push(@m, "\n");
  1960.  
  1961.     # Occasionally we may face this degenerate target:
  1962.     push @m, "test_ : test_dynamic\n\n";
  1963.  
  1964.     if ($self->needs_linking()) {
  1965.     push(@m, "test_static :: pure_all \$(MAP_TARGET)\n");
  1966.     push(@m, $self->test_via_harness('$(MAP_TARGET)', $tests)) if $tests;
  1967.     push(@m, $self->test_via_script('$(MAP_TARGET)', 'test.pl')) if -f 'test.pl';
  1968.     push(@m, "\n");
  1969.     push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n");
  1970.     push(@m, $self->test_via_script('$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)'));
  1971.     push(@m, "\n");
  1972.     }
  1973.     else {
  1974.     push @m, "test_static :: test_dynamic\n\t$self->{NOECHO}\$(NOOP)\n\n";
  1975.     push @m, "testdb_static :: testdb_dynamic\n\t$self->{NOECHO}\$(NOOP)\n";
  1976.     }
  1977.  
  1978.     join('',@m);
  1979. }
  1980.  
  1981. =item test_via_harness (override)
  1982.  
  1983. Use VMS-style quoting on command line.
  1984.  
  1985. =cut
  1986.  
  1987. sub test_via_harness {
  1988.     my($self,$perl,$tests) = @_;
  1989.     "    $perl".' "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)" \\'."\n\t".
  1990.     '-e "use Test::Harness qw(&runtests $verbose); $verbose=$(TEST_VERBOSE); runtests @ARGV;" \\'."\n\t$tests\n";
  1991. }
  1992.  
  1993. =item test_via_script (override)
  1994.  
  1995. Use VMS-style quoting on command line.
  1996.  
  1997. =cut
  1998.  
  1999. sub test_via_script {
  2000.     my($self,$perl,$script) = @_;
  2001.     "    $perl".' "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" '.$script.'
  2002. ';
  2003. }
  2004.  
  2005. =item makeaperl (override)
  2006.  
  2007. Undertake to build a new set of Perl images using VMS commands.  Since
  2008. VMS does dynamic loading, it's not necessary to statically link each
  2009. extension into the Perl image, so this isn't the normal build path.
  2010. Consequently, it hasn't really been tested, and may well be incomplete.
  2011.  
  2012. =cut
  2013.  
  2014. sub makeaperl {
  2015.     my($self, %attribs) = @_;
  2016.     my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) = 
  2017.       @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)};
  2018.     my(@m);
  2019.     push @m, "
  2020. # --- MakeMaker makeaperl section ---
  2021. MAP_TARGET    = $target
  2022. ";
  2023.     return join '', @m if $self->{PARENT};
  2024.  
  2025.     my($dir) = join ":", @{$self->{DIR}};
  2026.  
  2027.     unless ($self->{MAKEAPERL}) {
  2028.     push @m, q{
  2029. $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE)
  2030.     },$self->{NOECHO},q{Write Sys$Output "Writing ""$(MMS$TARGET)"" for this $(MAP_TARGET)"
  2031.     },$self->{NOECHO},q{$(PERL) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)" "-I$(PERL_ARCHLIB)" "-I$(PERL_LIB)" \
  2032.         Makefile.PL DIR=}, $dir, q{ \
  2033.         MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \
  2034.         MAKEAPERL=1 NORECURS=1
  2035.  
  2036. $(MAP_TARGET) :: $(MAKE_APERL_FILE)
  2037.     $(MMS)$(USEMAKEFILE)$(MAKE_APERL_FILE) static $(MMS$TARGET)
  2038. };
  2039.     push @m, map( " \\\n\t\t$_", @ARGV );
  2040.     push @m, "\n";
  2041.  
  2042.     return join '', @m;
  2043.     }
  2044.  
  2045.  
  2046.     my($linkcmd,@staticopts,@staticpkgs,$extralist,$target,$targdir,$libperldir);
  2047.  
  2048.     # The front matter of the linkcommand...
  2049.     $linkcmd = join ' ', $Config{'ld'},
  2050.         grep($_, @Config{qw(large split ldflags ccdlflags)});
  2051.     $linkcmd =~ s/\s+/ /g;
  2052.  
  2053.     # Which *.olb files could we make use of...
  2054.     local(%olbs);
  2055.     $olbs{$self->{INST_ARCHAUTODIR}} = "$self->{BASEEXT}\$(LIB_EXT)";
  2056.     require File::Find;
  2057.     File::Find::find(sub {
  2058.     return unless m/\Q$self->{LIB_EXT}\E$/;
  2059.     return if m/^libperl/;
  2060.  
  2061.     if( exists $self->{INCLUDE_EXT} ){
  2062.         my $found = 0;
  2063.         my $incl;
  2064.         my $xx;
  2065.  
  2066.         ($xx = $File::Find::name) =~ s,.*?/auto/,,;
  2067.         $xx =~ s,/?$_,,;
  2068.         $xx =~ s,/,::,g;
  2069.  
  2070.         # Throw away anything not explicitly marked for inclusion.
  2071.         # DynaLoader is implied.
  2072.         foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){
  2073.             if( $xx eq $incl ){
  2074.                 $found++;
  2075.                 last;
  2076.             }
  2077.         }
  2078.         return unless $found;
  2079.     }
  2080.     elsif( exists $self->{EXCLUDE_EXT} ){
  2081.         my $excl;
  2082.         my $xx;
  2083.  
  2084.         ($xx = $File::Find::name) =~ s,.*?/auto/,,;
  2085.         $xx =~ s,/?$_,,;
  2086.         $xx =~ s,/,::,g;
  2087.  
  2088.         # Throw away anything explicitly marked for exclusion
  2089.         foreach $excl (@{$self->{EXCLUDE_EXT}}){
  2090.             return if( $xx eq $excl );
  2091.         }
  2092.     }
  2093.  
  2094.     $olbs{$ENV{DEFAULT}} = $_;
  2095.     }, grep( -d $_, @{$searchdirs || []}));
  2096.  
  2097.     # We trust that what has been handed in as argument will be buildable
  2098.     $static = [] unless $static;
  2099.     @olbs{@{$static}} = (1) x @{$static};
  2100.  
  2101.     $extra = [] unless $extra && ref $extra eq 'ARRAY';
  2102.     # Sort the object libraries in inverse order of
  2103.     # filespec length to try to insure that dependent extensions
  2104.     # will appear before their parents, so the linker will
  2105.     # search the parent library to resolve references.
  2106.     # (e.g. Intuit::DWIM will precede Intuit, so unresolved
  2107.     # references from [.intuit.dwim]dwim.obj can be found
  2108.     # in [.intuit]intuit.olb).
  2109.     for (sort keys %olbs) {
  2110.     next unless $olbs{$_} =~ /\Q$self->{LIB_EXT}\E$/;
  2111.     my($dir) = $self->fixpath($_,1);
  2112.     my($extralibs) = $dir . "extralibs.ld";
  2113.     my($extopt) = $dir . $olbs{$_};
  2114.     $extopt =~ s/$self->{LIB_EXT}$/.opt/;
  2115.     if (-f $extralibs ) {
  2116.         open LIST,$extralibs or warn $!,next;
  2117.         push @$extra, <LIST>;
  2118.         close LIST;
  2119.     }
  2120.     if (-f $extopt) {
  2121.         open OPT,$extopt or die $!;
  2122.         while (<OPT>) {
  2123.         next unless /(?:UNIVERSAL|VECTOR)=boot_([\w_]+)/;
  2124.         # ExtUtils::Miniperl expects Unix paths
  2125.         (my($pkg) = "$1_$1$self->{LIB_EXT}") =~ s#_*#/#g;
  2126.         push @staticpkgs,$pkg;
  2127.         }
  2128.         push @staticopts, $extopt;
  2129.     }
  2130.     }
  2131.  
  2132.     $target = "Perl.Exe" unless $target;
  2133.     ($shrtarget,$targdir) = fileparse($target);
  2134.     $shrtarget =~ s/^([^.]*)/$1Shr/;
  2135.     $shrtarget = $targdir . $shrtarget;
  2136.     $target = "Perlshr.$Config{'dlext'}" unless $target;
  2137.     $tmp = "[]" unless $tmp;
  2138.     $tmp = $self->fixpath($tmp,1);
  2139.     if (@$extra) {
  2140.     $extralist = join(' ',@$extra);
  2141.     $extralist =~ s/[,\s\n]+/, /g;
  2142.     }
  2143.     else { $extralist = ''; }
  2144.     if ($libperl) {
  2145.     unless (-f $libperl || -f ($libperl = $self->catfile($Config{'installarchlib'},'CORE',$libperl))) {
  2146.         print STDOUT "Warning: $libperl not found\n";
  2147.         undef $libperl;
  2148.     }
  2149.     }
  2150.     unless ($libperl) {
  2151.     if (defined $self->{PERL_SRC}) {
  2152.         $libperl = $self->catfile($self->{PERL_SRC},"libperl$self->{LIB_EXT}");
  2153.     } elsif (-f ($libperl = $self->catfile($Config{'installarchlib'},'CORE',"libperl$self->{LIB_EXT}")) ) {
  2154.     } else {
  2155.         print STDOUT "Warning: $libperl not found
  2156.     If you're going to build a static perl binary, make sure perl is installed
  2157.     otherwise ignore this warning\n";
  2158.     }
  2159.     }
  2160.     $libperldir = $self->fixpath((fileparse($libperl))[1],1);
  2161.  
  2162.     push @m, '
  2163. # Fill in the target you want to produce if it\'s not perl
  2164. MAP_TARGET    = ',$self->fixpath($target),'
  2165. MAP_SHRTARGET = ',$self->fixpath($shrtarget),"
  2166. MAP_LINKCMD   = $linkcmd
  2167. MAP_PERLINC   = ", $perlinc ? map('"$_" ',@{$perlinc}) : '','
  2168. # We use the linker options files created with each extension, rather than
  2169. #specifying the object files directly on the command line.
  2170. MAP_STATIC    = ',@staticopts ? join(' ', @staticopts) : '','
  2171. MAP_OPTS    = ',@staticopts ? ','.join(',', map($_.'/Option', @staticopts)) : '',"
  2172. MAP_EXTRA     = $extralist
  2173. MAP_LIBPERL = ",$self->fixpath($libperl),'
  2174. ';
  2175.  
  2176.  
  2177.     push @m,'
  2178. $(MAP_SHRTARGET) : $(MAP_LIBPERL) $(MAP_STATIC) ',"${libperldir}Perlshr_Attr.Opt",'
  2179.     $(MAP_LINKCMD)/Shareable=$(MMS$TARGET) $(MAP_OPTS), $(MAP_EXTRA), $(MAP_LIBPERL) ',"${libperldir}Perlshr_Attr.Opt",'
  2180. $(MAP_TARGET) : $(MAP_SHRTARGET) ',"${tmp}perlmain\$(OBJ_EXT) ${tmp}PerlShr.Opt",'
  2181.     $(MAP_LINKCMD) ',"${tmp}perlmain\$(OBJ_EXT)",', PerlShr.Opt/Option
  2182.     ',$self->{NOECHO},'Write Sys$Output "To install the new ""$(MAP_TARGET)"" binary, say"
  2183.     ',$self->{NOECHO},'Write Sys$Output "    $(MMS)$(USEMAKEFILE)$(MAKEFILE) inst_perl $(USEMACROS)MAP_TARGET=$(MAP_TARGET)$(ENDMACRO)"
  2184.     ',$self->{NOECHO},'Write Sys$Output "To remove the intermediate files, say
  2185.     ',$self->{NOECHO},'Write Sys$Output "    $(MMS)$(USEMAKEFILE)$(MAKEFILE) map_clean"
  2186. ';
  2187.     push @m,'
  2188. ',"${tmp}perlmain.c",' : $(MAKEFILE)
  2189.     ',$self->{NOECHO},'$(PERL) $(MAP_PERLINC) -e "use ExtUtils::Miniperl; writemain(qw|',@staticpkgs,'|)" >$(MMS$TARGET)
  2190. ';
  2191.  
  2192.     push @m, q[
  2193. # More from the 255-char line length limit
  2194. doc_inst_perl :
  2195.     ].$self->{NOECHO}.q[$(PERL) -e "print 'Perl binary $(MAP_TARGET)|'" >.MM_tmp
  2196.     ].$self->{NOECHO}.q[$(PERL) -e "print 'MAP_STATIC|$(MAP_STATIC)|'" >>.MM_tmp
  2197.     ].$self->{NOECHO}.q[$(PERL) -pl040 -e " " ].$self->catfile('$(INST_ARCHAUTODIR)','extralibs.all'),q[ >>.MM_tmp
  2198.     ].$self->{NOECHO}.q[$(PERL) -e "print 'MAP_LIBPERL|$(MAP_LIBPERL)|'" >>.MM_tmp
  2199.     $(DOC_INSTALL) <.MM_tmp >>].$self->catfile('$(INSTALLARCHLIB)','perllocal.pod').q[
  2200.     ].$self->{NOECHO}.q[Delete/NoLog/NoConfirm .MM_tmp;
  2201. ];
  2202.  
  2203.     push @m, "
  2204. inst_perl : pure_inst_perl doc_inst_perl
  2205.     \$(NOOP)
  2206.  
  2207. pure_inst_perl : \$(MAP_TARGET)
  2208.     $self->{CP} \$(MAP_SHRTARGET) ",$self->fixpath($Config{'installbin'},1),"
  2209.     $self->{CP} \$(MAP_TARGET) ",$self->fixpath($Config{'installbin'},1),"
  2210.  
  2211. clean :: map_clean
  2212.     \$(NOOP)
  2213.  
  2214. map_clean :
  2215.     \$(RM_F) ${tmp}perlmain\$(OBJ_EXT) ${tmp}perlmain.c \$(MAKEFILE)
  2216.     \$(RM_F) ${tmp}PerlShr.Opt \$(MAP_TARGET)
  2217. ";
  2218.  
  2219.     join '', @m;
  2220. }
  2221.   
  2222. =item ext (specific)
  2223.  
  2224. Stub routine standing in for C<ExtUtils::LibList::ext> until VMS
  2225. support is added to that package.
  2226.  
  2227. =cut
  2228.  
  2229. sub ext {
  2230.     my($self) = @_;
  2231.     '','','';
  2232. }
  2233.  
  2234. # --- Output postprocessing section ---
  2235.  
  2236. =item nicetext (override)
  2237.  
  2238. Insure that colons marking targets are preceded by space, in order
  2239. to distinguish the target delimiter from a colon appearing as
  2240. part of a filespec.
  2241.  
  2242. =cut
  2243.  
  2244. sub nicetext {
  2245.  
  2246.     my($self,$text) = @_;
  2247.     $text =~ s/([^\s:])(:+\s)/$1 $2/gs;
  2248.     $text;
  2249. }
  2250.  
  2251. 1;
  2252.  
  2253. __END__
  2254.  
  2255.